<!-- 物资/服务 tabs切换 -->
<template>
  <el-tabs
    :value="activeName"
    type="card"
    :style="{ 'margin-top': isShowBtn ? '0px' : '36px' }"
    @tab-click="handleClick"
  >
    <el-tab-pane label="物资明细信息" name="物资明细信息">
      <!-- 物资明细信息table -->
      <MaterialServiceDetails
        v-if="!ishowTabs"
        ref="myTable"
        :columns="tableOption.colOptionMaterial"
        :is-show-dilog="tableOption.isShowDilog"
        :save-materialdetails="saveMaterialdetails"
        :table-data="tableOption.tablDataMaterial"
        :active-name="activeName"
        :url-data="getUrlData"
        @tableInput="hanldeinputChange"
        @closeDialog="closeDialog"
        @saveTempalte="saveTempalte"
      />
    </el-tab-pane>
    <el-tab-pane label="服务明细信息" name="服务明细信息">
      <!-- 服务明细信息table -->
      <MaterialServiceDetails
        v-if="ishowTabs"
        ref="myTable"
        :url-data="getUrlData"
        :is-show-fixed="true"
        :columns="tableOption.colOptionService"
        :save-materialdetails="saveMaterialdetails"
        :services-select="tableOption.servicesSelect"
        :table-data="tableOption.tablDataService"
        :services-columns="tableOption.servicesColumns"
        :is-selection="true"
        :active-name="activeName"
        @tableInput="hanldeinputChange"
        @saveTempalte="saveTempalte"
        @selectInfo="selectInfo"
        @handleSelection="handleSelection"
        @isClose="isClose"
      />
    </el-tab-pane>
  </el-tabs>
</template>

<script>
import { colOptionMaterial, colOptionService, servicesColumns } from '../index.js'
import MaterialServiceDetails from './MaterialServiceDetails.vue'
import {
  getMaterialDetails,
  updateEquips,
  getServicesdetails,
  updateServicesEquips,
  getSelectSupper,
  getSelectUsers,
  saveMaterialAdjust,
  getBalanceBasicDetails,
  upPushSuppliers,
  backSuppliers,
  pushServerCooperation,
  pushMateriaCooperation
} from '@/api/settlement/balanceSettlement.js'
import {
  getWFWorkItem
} from '@/api/actualBudget/index'
// import VeriFication from '../VeriFication.js'
import { Message } from 'element-ui'
import { msgInfoEl } from '@/utils'
// const {
//   verificationMaterial,
//   filterUpdataTableRow,
//   serviceVerification,
//   filteredWithParents,
//   isPossibleToPush
// } = VeriFication()
export default {
  name: 'SwitchTabs',
  components: {
    MaterialServiceDetails
  },
  props: {
    paramsObj: {
      type: Object,
      default: () => ({ })
    },
    urlData: {
      type: Object,
      default: () => ({ })
    },
    prjDetails:{
            type: Object,
            default: () => ({ })
        }
  },
  data() {
    return {
      // 选中的tabs项
      activeName: '物资明细信息',
      // 表格中的配置
      tableOption: {
        // 物资明细信息表头
        colOptionMaterial,
        // 服务明细信息表头
        colOptionService,
        // 服务明细表头2
        servicesColumns,
        // 服务商下拉框字典数据
        servicesSelect: {
        },
        // 物资表格数据
        tablDataMaterial: [
        ],
        // 服务表格数据
        tablDataService: [
        ],
        provisionalCount: '', // 记录上一次单元格选择的值
        recordIndex: [], // 记录上一次单元格选择的值的下标
        rocordId: [], // 服务过滤需要唯一的id
        isShowDilog: false// 是否显示弹框 物资子专业绑定
      },
      clickRow: {}, // 服务商选择下拉框需要多一条数据 我需要拿到当前点击的哪一行
      backSuppersInfo: [], // 退回供应商选择的数组
      isShowBtn: true, // 是否让margin
      deepRowList: [], // 深拷贝一份服务商下拉框数据
      pollingPersonList: {}// 下拉框人员选择数据信息
    }
  },
  computed: {
    // 计算属性判断是否显示那个模块组件表格
    ishowTabs() {
      return this.activeName === '物资明细信息' ? 0 : 1
    },
    // 重要 判断是否是全屏来的 还是 默认进来的浏览器地址携带参数
    getUrlData() {
      return this.paramsObj?.adjustId !== undefined ? this.paramsObj : this.urlData
    },
    isSoftProject(){
            return this.prjDetails.isNewbusiness === '1' && ['29','25'].includes(this.prjDetails.buildModes) 
        },
  },
  created() {
    // 初始化调用获取物资明细信息
    this.initMaterialdetails()
    this.initServicesdetails()
    // 是否显示所有按钮
    if (this.getUrlData.type === 'done') {
      // 这个判断当前是从已办还是代办进来的 done以办 所有按钮不显示 不可编辑
      this.showPages()
    } else {
      // 判断当前是那个节点并调用接口
      this.changeBtnTypeTabs()
    }
  },
  methods: {
    // 如果已办则不显示按钮也不能点击
    showPages() {
      this.$nextTick(() => {
        this.$refs.myTable.changeBtnType('D')
      })
      this.$emit('showBtn', false)
    },
    // 下拉框选项的信息
    selectInfo(data) {
      const [item, row, label] = data
      this.tableOption.rocordId.push(row.id)
      // 每次选完清空人员
      if (item === 'serviceName') {
        row['serviceUserId'] = ''
        row['serviceUserName'] = ''
      }
      // this.initSelectUsers(label)
    },
    uniqueByPropertyUsingSet(arr, prop) {
      const seen = new Set()
      return arr.filter(item => {
        const key = item[prop]
        return seen.has(key) ? false : seen.add(key)
      })
    },
    // 获取服务商 下拉框接口
    async initSelectSupper() {
      const { prjId } = this.getUrlData
      const { code, data } = await getSelectSupper(prjId)
      if (+code === 200) {
        // 深拷贝一份数据
        this.deepRowList = JSON.parse(JSON.stringify(data))
        this.$set(this.tableOption.servicesSelect, 'PROVIDERS', data)
        // 1.需要把表格中的供应商编码和名称添加到下拉框中
        const tableSelect = this.tableOption.tablDataService.map(item => {
          return {
            serviceCode: item?.supplierCode,
            serviceName: item?.supplierName
          }
        })
        // 合并数组
        const mergeArrList = [...data, ...tableSelect]
        // 去重
        const uniqueArray = this.uniqueByPropertyUsingSet(mergeArrList, 'serviceCode')
        // 由于抖动问题必须把数据存起来不能重复调用接口
        for (let i = 0; i < uniqueArray.length; i++) {
          // 获取轮询以后的人员结果
          const backPersonData = await this.initSelectUsers(uniqueArray[i]?.serviceCode)
          this.$set(this.pollingPersonList, uniqueArray[i]?.serviceCode, backPersonData)
        }
      }
    },
    // 获取人员下拉框接口
    async initSelectUsers(row) {
      const { prjId } = this.getUrlData
      const { code, data } = await getSelectUsers(prjId, row)
      if (+code === 200) {
        return data
      }
    },
    // 获取物资明细信息接口
    async initMaterialdetails() {
      const { adjustId } = this.getUrlData
      const res = await getMaterialDetails(adjustId)
      if (+res.code === 200) {
        this.tableOption.tablDataMaterial = res.data
        // 获取服务商下拉框接口
        this.initSelectSupper()
      }
    },
    // 获取服务明细信息接口
    async initServicesdetails() {
      const { adjustId } = this.getUrlData
      const { code, data } = await getServicesdetails(adjustId)
      if (+code === 200) {
        // 判断字段是否存在 存在则把名称信息直接赋值
        data.forEach(item => {
          if (+item?.isContainSupplier === 1) {
            item.serviceCode = item?.supplierCode
            item.serviceName = item?.supplierName
          }
        })
        this.tableOption.tablDataService = data
      }
    },
    // 切换tab 提示是否进行编辑
    isEditClick() {
      this.$confirm('本次工程量有修改，是否保存本次调整？', '系统提示', {
        confirmButtonText: '保存',
        cancelButtonText: '取消',
        cancelButtonClass: 'pms-zr-button',
        confirmButtonClass: 'pms-zr-button-primary',
        type: 'warning'
      }).then(() => {
        this.activeName = this.activeName === '物资明细信息' ? '服务明细信息' : '物资明细信息'
        this.settleConfirm()
      }).catch(() => {
        this.tableOption.recordIndex = []
        this.tableOption.rocordId = []
        this.$message({
          type: 'info',
          message: '取消修改'
        })
        sessionStorage.removeItem('recordIndex')
        sessionStorage.removeItem('rocordId')
      })
    },
    // 下一步校验是否保存
    nextIsEditClick() {
      this.$confirm('本次工程量有修改，是否保存本次调整？', '系统提示', {
        confirmButtonText: '保存',
        cancelButtonText: '取消',
        cancelButtonClass: 'pms-zr-button',
        confirmButtonClass: 'pms-zr-button-primary',
        type: 'warning'
      }).then(() => {
        this.nextSettleConfirm()
      }).catch(() => {
        // 取消不允许弹框显示
        this.$emit('nextBtnDilogShow', false)
      })
    },
    changeMaterialSaveListBackStatus() {
      const materialStatus = this.tableOption.tablDataMaterial.some(item => (+item.status) === 1)
      return materialStatus
    },
    changeServerSaveListBackStatus() {
      const backStatus = this.tableOption.tablDataService.some(item => {
        return item.childNodeList.some(_item => (+_item.status) === 1)
      })
      return backStatus
    },
    // tabs 切换事件
    async handleClick(tab, event) {
      // 判断物资和服务是否改变了
      const dataStatusListOne = this.filterUpdataTableRow(this.tableOption.tablDataMaterial, this.tableOption.recordIndex, this.activeName).filter((item) => +item.status === 1)
      const dataStatusListTwo = this.filteredWithParents(this.filterUpdataTableRow(this.tableOption.tablDataService, this.tableOption.rocordId, this.activeName)).filter(i => {
        if (i.childNodeList.length > 0) {
          i.childNodeList.filter(children => +children.status === 1)
        }
      })
      // 切换的时候判断是否修改了 修改了就会提示 是否保存 或取消
      if (this.tableOption.recordIndex.length > 0 && dataStatusListOne.length > 0 && this.changeMaterialSaveListBackStatus()) {
        this.isEditClick()
      }
       if ((this.tableOption.rocordId.length > 0 || dataStatusListTwo.length > 0) && this.changeServerSaveListBackStatus()) {
        this.isEditClick()
      }
      // 看是代办还是已办
      if (this.getUrlData.type === 'done') {
        this.showPages()
      } else {
        this.changeBtnTypeTabs()
      }
      // 关闭物资子专业绑定弹窗
      this.tableOption.isShowDilog = false
      this.activeName = tab.name
      if (tab.name === '物资明细信息') {
        // 获取物资明细信息
        this.initMaterialdetails()
      } else {
        // 获取服务明细信息
        this.initServicesdetails()
      }
    },
    // 修改单元的数据
    async hanldeinputChange(data) {
      // 选中单元格数据  表格数据下表 为了上一次数据回显 物资
      if (this.activeName === '物资明细信息') {
        this.tableOption.recordIndex.push(data[1])
        sessionStorage.setItem('recordIndex', JSON.stringify(this.tableOption.recordIndex))
      } else {
        this.tableOption.rocordId.push(data[2]?.id)
        sessionStorage.setItem('rocordId', JSON.stringify(this.tableOption.rocordId))
      }
      //  判断逻辑
      if (this.activeName === '物资明细信息') {
        // 物资校验单元格数据
        this.verificationMaterial(data, this.tableOption.tablDataMaterial, this.tableOption.provisionalCount, this.tableOption.colOptionMaterial)
      } else {
        // 服务校验单元格数据
        this.serviceVerification(data, this.tableOption.tablDataService, this.tableOption.provisionalCount, this.tableOption.colOptionService)
      }
    },
    // 保存明细接口 根据不同按钮类型调用不同方法  Materialdetails 页面
    async saveMaterialdetails(fun) {
      // 调用方法
      this[fun]()
    },
    // 保存明细接口2024.9.29优化代码
    async settleConfirm() {
      let _resultCode = ''
      // 判断当前是物资/服务保存
      if (this.activeName === '物资明细信息') {
        this.settleConfirmOne()
      } else {
        if (this.tableOption.rocordId.length === 0) {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
        // 最终保存的数据
        _resultCode = this.settleConfirmTwo()
      }
      // 每次保存以后清空选中的index
      this.tableOption.recordIndex = []
      this.tableOption.rocordId = []
      return _resultCode
    },
    // 2024.9.29优化代码
    async settleConfirmOne() {
      // 拿到过滤后需要保存的数据
      const data = this.filterUpdataTableRow(this.tableOption.tablDataMaterial, this.tableOption.recordIndex, this.activeName)
        if (data.length > 0) {
          // 调用接口
          const { code } = await updateEquips(data)
          if (+code === 200) {
            this.$message({
              message: '保存成功',
              type: 'success'
            })
            // 清除保存的信息
            sessionStorage.removeItem('recordIndex')
            // 调用接口查询重新赋值表格
            await this.initMaterialdetails()
          }
        } else {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
    },
    // 2024.9.29优化代码
    async settleConfirmTwo() {
      const data = this.filteredWithParents(this.filterUpdataTableRow(this.tableOption.tablDataService, this.tableOption.rocordId, this.activeName))
        if (data.length > 0) {
          // 需要传一个processInstId
          const { processInstId } = this.getUrlData
          const { code } = await updateServicesEquips(data, processInstId)
          if (+code === 200) {
            this.$message({
              message: '保存成功',
              type: 'success'
            })
            // 清除保存的信息
            sessionStorage.removeItem('rocordId')
            // 获取服务明细信息
            this.initServicesdetails()
            this.tableOption.rocordId = []
            return code
          }
        } else {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
    },
     // 2024.9.29优化代码
     async settleConfirmThree(materia) {
      const data = this.filterUpdataTableRow(this.tableOption.tablDataMaterial, materia, this.activeName)
        if (data.length > 0) {
          // 调用接口
          const { code } = await updateEquips(data)
          if (+code === 200) {
            this.$message({
              message: '保存成功',
              type: 'success',
              duration: 300
            })
            // 保存成功移除存储的信息
            sessionStorage.removeItem('recordIndex')
            // 保存以后让下一步弹框显示
            this.$emit('nextBtnDilogShow', true)
            // 调用接口查询重新赋值表格
            await this.initMaterialdetails()
          }
        } else {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
     },
      // 2024.9.29优化代码
      async settleConfirmFour(services) {
        const data = this.filteredWithParents(this.filterUpdataTableRow(this.tableOption.tablDataService, services, this.activeName))
        if (data.length > 0) {
          // 需要传一个processInstId
          const { processInstId } = this.getUrlData
          const { code } = await updateServicesEquips(data, processInstId)
          if (+code === 200) {
            this.$message({
              message: '保存成功',
              type: 'success',
              duration: 300
            })
            // 保存成功移除存储的信息
            sessionStorage.removeItem('rocordId')
            // 保存以后让下一步弹框显示
            this.$emit('nextBtnDilogShow', true)
            // 获取服务明细信息
            this.initServicesdetails()
            return code
          }
        } else {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
      },
    // 下一步保存明细接口
    // 保存明细接口
    async nextSettleConfirm() {
      // 判断物资是否保存了
      const materia = JSON.parse(sessionStorage.getItem('recordIndex'))
      // 判断服务是否保存了
      const services = JSON.parse(sessionStorage.getItem('rocordId'))
      // 判断当前是物资/服务保存
      if (this.activeName === '物资明细信息') {
        // 拿到过滤后需要保存的数据
        this.settleConfirmThree(materia)
      } else {
        if (services.length === 0) {
          return this.$message({
            message: '没有改动不需要保存！'
          })
        }
        // 最终保存的数据
       this.settleConfirmFour(services)
      }
    },
    // 结算确认按钮
    async balanceConfirm() {
      if (this.activeName === '物资明细信息') {
        // 结算确认接口
        this.balanceConfirmMaterial()
      } else {
        this.balanceConfirmMaterial()
      }
      // 判断当前到那个节点
      this.changeBtnTypeTabs()
    },
    // 物资服务明细结算确认按钮
    async balanceConfirmMaterial() {
      const staffId = JSON.parse(sessionStorage.getItem('SET_LOGINDATA'))?.staffId
      const { prjId, processInstId, adjustId, workItemId } = this.getUrlData
      const { code, message } = await saveMaterialAdjust(prjId, processInstId, adjustId)
      // 子专业绑定弹框打开
      if (+code === 5555) {
        // 让弹框显示  校验不通过才能显示弹框
        this.$alert(`${message}`, '系统提示', {
          confirmButtonText: '确定',
          // 将字符串html化
          dangerouslyUseHTMLString: true,
          cancelButtonClass: 'pms-zr-button',
          confirmButtonClass: 'pms-zr-button-primary',
          callback: action => {
            this.tableOption.isShowDilog = true
          }
        })
      }
      // 成功跳转到结算送审
      if (+code === 200) {
        this.$message({
          message: `${message}`,
          type: 'success'
        })
        // 跳转到结算送审页面
        window.open(`${process.env.VUE_APP_ZHONGRUAN_URL}communicationSubmitApproval?prjId=${prjId}&pushPerson=${staffId}&ifGotoShManager=null&workItemId=${workItemId}`, '_blank')
      }
      if (+code !== 200 && +code !== 5555) {
        msgInfoEl({
          message: message || '操作异常',
          type: 'error'
        })
      }
    },
    // 服务推送供应商接口
    async pushSupplier() {
      if (this.tableOption.rocordId.length > 0) {
        // 如果没有保存 则先保存以后才可以推送
        const sendCode = await this.settleConfirm()
        if (+sendCode === 200) {
          this.pushBalaceSuppiers()
        }
      } else {
        this.pushBalaceSuppiers()
      }
    },
    // 推送供应商接口
    async pushBalaceSuppiers() {
      const { adjustId, prjId, processInstId } = this.getUrlData
      const { code } = await upPushSuppliers(adjustId, prjId, processInstId)
      if (+code === 200) {
        this.$message({
          message: '服务商推送成功',
          type: 'success'
        })
        // 获取服务明细信息
        this.initServicesdetails()
        // 判断当前到那个节点
        this.changeBtnTypeTabs()
      }
    },
    // 服务退回供应商
    async backTosupplier() {
      // 需要选中 的数据 以及 processInstId 退回的数据
      const { processInstId } = this.getUrlData
      // 判断回退意见是否填写了
      const isAll = this.backSuppersInfo.every(item => {
        if (item.childNodeList) {
          if (item.childNodeList.every(_item => _item.returnInforMation === '' || _item.returnInforMation === null)) {
            return false
          } else {
            return true
          }
        }
      })
      if (this.backSuppersInfo.length === 0) {
        return this.$message({
          message: `请选择一条数据`,
          type: 'warning'
        })
      }
      if (!isAll) {
        return this.$message({
          message: `回退调整意见不能为空`,
          type: 'warning'
        })
      }
      const { code } = await backSuppliers(this.backSuppersInfo, processInstId)
      if (+code === 200) {
        this.$message({
          message: '退回供应商成功',
          type: 'success'
        })
        // 清空多选框
        this.$refs.myTable.clearCheckBox()
        // 判断当前到那个节点
        this.changeBtnTypeTabs()
      }
    },
    // 推送商合
    async pusherAnd() {
      // 先推送服务 异步接口以后才能推送物资
      const { prjId, adjustId, processInstId } = this.getUrlData
      // 先判断当前属于那个状态
      const { pushState, promptMsg } = await this.getBalanceBasicInfo()
      // 推送服务成功，然后推送物资
      if (+pushState === 1 || +pushState === 4) {
        const { code } = await pushMateriaCooperation(prjId, adjustId, processInstId)
        if (+code === 200) {
          this.$message({
            message: '推送商合成功',
            type: 'success'
          })
        }
        this.changeBtnTypeTabs()
        return
      }
      // 推送服务
      if (+pushState === 3) {
        const { code } = await pushServerCooperation(prjId, adjustId, 'SETTLEMENT', processInstId)
        if (+code === 200) {
          this.$message({
            message: '推送商合成功',
            type: 'success'
          })
        }
        this.changeBtnTypeTabs()
        return
      }
      // 等待交易处理服务结果
      if (+pushState === 2) {
        return this.$message({
          message: '交易系统正在进行合同信息校验及数据处理，过程中请点击【推送商合进度】按钮查看进度',
          type: 'warning'
        })
      }
      if (+pushState === 5) { // 未调整
        return this.$message({
          message: promptMsg,
          type: 'warning'
        })
      }
      if (+pushState === 6) { // 都已推送成功
        return this.$message({
          message: promptMsg,
          type: 'warning'
        })
      }
      if (+pushState === 0) {
        this.$confirm(`${promptMsg}, 是否继续推送?`, '提示', {
          confirmButtonText: '是',
          cancelButtonText: '否',
          cancelButtonClass: 'pms-zr-button',
          confirmButtonClass: 'pms-zr-button-primary',
          type: 'warning'
        }).then(async() => {
          const { code } = await pushServerCooperation(prjId, adjustId, 'SETTLEMENT', processInstId)
          if (+code === 200) {
            this.$message({
              message: '推送商合成功',
              type: 'success'
            })
            this.changeBtnTypeTabs()
          }
        }).catch(() => {
          this.$message({
            type: 'info',
            message: '取消推送'
          })
        })
      }
      // 判断当前到那个节点
      this.changeBtnTypeTabs()
    },
    // 推送商合进度
    async pusherAndSchedule() {
      // 查看当前推送结果
      const { promptMsg } = await this.getBalanceBasicInfo()
      this.$message({
        message: promptMsg,
        type: 'warning'
      })
      // 判断当前到那个节点
      this.changeBtnTypeTabs()
    },
    // 结算确认的子专业绑定弹框隐藏
    closeDialog(show) {
      // 结算确认弹框隐藏
      this.tableOption.isShowDilog = show
    },
    // 暂存某个单元格里面的值
    saveTempalte(data) {
      // 获取单元格上一次选择的值
      const [, , lastCount] = data
      this.tableOption.provisionalCount = lastCount
    },
    // 是否显示推送供应商/退回/推送商合/推送商合进度按钮
    async getBalanceInfoDetails() {
      const { adjustId } = this.getUrlData
      // 获取结算当前基本信息
      const { code, data } = await getBalanceBasicDetails(adjustId)
      if (+code === 200) {
        return data
      }
    },
    // 更改按钮显示类型调用子组件方法 MaterialServiceDetails
    async changeBtnTypeTabs() {
      // 获取当前基本信息
      const objData = await this.getBalanceInfoDetails()
      // 从浏览器地址栏获取  判断当前是那个节点
      const { workItemId } = this.getUrlData
      if (!workItemId) {
        this.isShowBtn = false
        return
      }
      const { code, data } = await getWFWorkItem({ workItemId: workItemId })
      if (+code === 200) {
        // sett_01结算确认 ,sett_02 审核环节,sett_03 结算送审
        const { activityDefID } = data
        // 物资明细比较特殊 如果是结算确认则只展示保存明细按钮
        if (activityDefID !== 'sett_01') {
          // 不显示更新商合订单按钮 所以margin-top需要给个20px
          this.isShowBtn = false
        }
        // 由于组件销毁所以拿不到
        if (this.$refs.myTable !== undefined) {
          // 当前节点 以及是否显示节点里面那个按钮
          this.$refs.myTable.changeBtnType(activityDefID, objData, this.activeName)
        }
      }
    },
    // 获取结算基本信息
    async getBalanceBasicInfo() {
      const { adjustId } = this.getUrlData
      const { code, data } = await getBalanceBasicDetails(adjustId)
      let listObj = {}
      if (+code === 200) {
        listObj = this.isPossibleToPush(data)
      }
      return listObj
    },
    // 勾选框选中的行
    handleSelection(rowList) {
      // 选中的数组行赋值给表格
      this.backSuppersInfo = rowList
    },
    // 是否开启状态 让下拉框数据对一条当前表格行服务商的
    isClose(row) {
      const [_row, item] = row
      this.clickRow = _row
      //  人员选择
      if (item === 'serviceUserName') {
        this.personSelectOption(row)
      } else {
        // 服务商 选择
        this.servicerSelectOption(row)
      }
    },
    // 服务商逻辑下拉框选择之后为了解决抖动的问题
    servicerSelectOption(row) {
      // 判断当前选择的是哪一行的数据
      const result = this.tableOption.tablDataService.filter(item => item.id === row[0].id)
      // 判断选择的行是否有数据并且开关是打开的
      if (result.length > 0 && +result[0].isClose === 0) {
        // 拿到当前行的数据并且插入到下拉框数组中
        const obj = { serviceCode: result[0]?.supplierCode, serviceName: result[0]?.supplierName }
        if (this.tableOption.servicesSelect.PROVIDERS.findIndex(item => item.serviceCode === obj.serviceCode) === -1) {
          // 判断如果当前下拉框中已经存在则不允许重复添加&&不能把其他行的数据添加过来
          if (this.tableOption.servicesSelect.PROVIDERS.length >= this.deepRowList.length + 1) {
            // 删除上次添加的最后一项在添加
            this.tableOption.servicesSelect.PROVIDERS.pop()
            this.tableOption.servicesSelect.PROVIDERS.push(obj)
          } else {
            this.tableOption.servicesSelect.PROVIDERS.push(obj)
          }
        }
      } else {
        // isClose 关闭的时候 把服务商人员已经包括了的数据去掉
        const filterList = this.tableOption.servicesSelect.PROVIDERS.filter(item => item.serviceCode !== result[0]?.supplierCode)
        this.tableOption.servicesSelect.PROVIDERS = filterList
      }
    },
    // 人员选择以后操作为了解决抖动的问题
    personSelectOption(row) {
      const ids = row[0]?.serviceCode
      // 如果说服务商选择了才会调用处理逻辑否则不做处理
      if (ids && ids !== null) {
        this.$set(this.tableOption.servicesSelect, 'PERSON', this.pollingPersonList[ids])
      } else {
        this.$set(this.tableOption.servicesSelect, 'PERSON', [])
      }
    },
    verificationMaterial(data, tableData, lastCount, column) {
      const ifSinglePro = '0'// 是否单项工程项目1时，0否  从 url获取存在就拿不存在给0
      const [item, , row] = data // 这是当前点击表格哪一行的 值 item是点击那个单元格  row 是表格的行
      // 判断当前点击那个单元格 单价增调数量
      if (item === 'changeNum') {
        // 调用增调数量的逻辑方法
        this.updateNum(row, tableData, ifSinglePro, lastCount)
      } else if (item === 'changePrice') { // 点击的是合价
        this.updatePrice(row, lastCount)
      } else if (item === 'usableStorage') { // 点击的是入库可用
        this.updateUsableStorage(row, lastCount)
      } else if (item === 'unUsableStorage') { // 点击的是入库不可用
        this.updateUnusableStorage(row, lastCount)
      } else if (item === 'notUsableStorage') { // 点击的是不入库可用
        this.updateNotUsableStorage(row, lastCount)
      } else if (item === 'notUnusableStorage') { // 点击的是不入库不可用
        this.updateNotUNusableStorage(row, lastCount)
      } else {
        console.log('[]')
      }
    },
     // 2024-9-26 阻断问题if过多解决方案
    optimizeNewUpdateNumOne(row) {
      return !(row['doneNum'] === '' || row['doneNum'] == null)
    },
    optimizeNewUpdateNumTwo(row) {
      return +row['changeNum'] === 0 || row['changeNum'] === '' || row['changeNum'] == null
    },
    optimizeNewUpdateNumThree(row) {
      return !(row['changeNum'] === '' || +row['changeNum'] === 0)
    },
    optimizeNewUpdateNumFour(row) {
      return row['taxRate'] === '' || row['taxRate'] == null
    },
    optimizeNewUpdateNumFive(row) {
        let changeStatus = row['changeStatus']
        if (row['changeNum'] > 0) {
          changeStatus = '0'
        } else {
          changeStatus = '1'
        }
        return changeStatus
    },
    updateNum(row, tableData, ifSinglePro, lastCount) {
      // 定义一个变量 看增调数量和数量
      const doneNum1 = parseFloat(+row['changeNum']) + parseFloat(+row['amount'])
      // 如果doneNum 不存在 则置空
      if (this.optimizeNewUpdateNumOne(row)) {
        row['changeNum'] = +row['changeNum'] // 给增调数量赋值
        row['doneNum'] = +row['doneNum'] // 变化后数量
      } else {
        row['changeNum'] = +row['changeNum']// 给增调数量赋值
      }
      // 如果doneNum1<0 提示消息
      if (doneNum1 < 0) {
        // 提示消息
        Message({
          message: `变化后数量”的计算结果不能为负数！`,
          type: 'warning'
        })
        row['changeNum'] = '' // 给增调数量赋值
        row['status'] = 0 // 状态赋值
      } else if (this.optimizeNewUpdateNumTwo(row)) { // 如果数量===0
        row['status'] = 0 // 状态改为未改变
        row['doneNum'] = '' // 变化后数量
        row['donePrice'] = ''// 变化后合价
        row['changePrice'] = ''// 变化合价
        row['changeStatus'] = ''// 状态
        row['doneAmt'] = ''// 调整后含税总价(元)
        row['doneTaxAmount'] = ''// 调整后税额(元)
        row['changeNum'] = ''// 增调数量
      } else if (this.optimizeNewUpdateNumThree(row)) { // 如果数量！==0&&！==""
        row['status'] = 1 // 状态赋值
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = this.optimizeNewUpdateNumFive(row) // 状态
        // 变化后合价
        row['donePrice'] = Number(parseFloat(doneNum1)) * parseFloat(+row['price']) // 26.8155
        // 合价(不含税) 不===null
        if (row['equipSum'] == null) {
          row['equipSum'] = 0 // 26.55 合价(不含税)
        }
        // 税率存在
        if (this.optimizeNewUpdateNumFour(row)) {
          row['taxRate'] = 0 // 税率
        }
        // 变化合价
        row['changePrice'] = parseFloat(+row['donePrice']) - parseFloat(+row['equipSum'])
        // 调整后税额(元)
        row['doneTaxAmount'] = parseFloat(+row['donePrice']) * parseFloat(+row['taxRate'])
        // 调整后含税总价(元)
        row['doneAmt'] = parseFloat(+row['donePrice']) + parseFloat(+row['doneTaxAmount'])
        // 赋值
        row['changeNum'] = (+row['changeNum']) // 增调数量
        row['doneNum'] = doneNum1 // 变化后数量
        row['changePrice'] = (+row['changePrice']).toFixed(2) // 变化合价
        row['donePrice'] = (+row['donePrice']).toFixed(2) // 变化后合价(不含税)
        row['doneAmt'] = (+row['doneAmt']).toFixed(2) // 调整后含税总价(元)
        row['doneTaxAmount'] = (+row['doneTaxAmount']).toFixed(2) // 调整后税额(元)
      } else {
        console.log('')
      }
    },
    // 物资明细 -校验合价
    updatePrice(row, lastCount) {
      console.log('changePrice')
      // // 定义一个变量 变化合价 /合价(不含税)
      // const s = Math.abs(+row['changePrice']) / +row['equipSum']
      // // 定义一个变量变化合价 +合价(不含税)
      // const donePrice1 = parseFloat(+row['changePrice']) + parseFloat(+row['equipSum'])
      // // 判断满足条件
      // if (s > row['priceConfig']) {
      //   // 提示消息
      //   this.messagePrompt(`仅用于工程量调整引起的合价变化，严禁改变采购单价（变化超过"${+row['priceConfig'] * 100}"%）!`)
      //   row['changePrice'] = lastCount || 0 // 变化合价
      //   row['status'] = 0 // 状态
      //   // 变化后合价 逻辑存在
      //   if (row['donePrice'] === '' || row['donePrice'] == null) {
      //     row['changePrice'] = '' // 变化后合价
      //   }
      //   if (!(row['donePrice'] === '' || row['donePrice'] == null)) {
      //     row['changePrice'] = (+row['changePrice']) // 变化合价
      //     row['donePrice'] = (+row['donePrice']) // 调整后合价(不含税)
      //   }
      // } else if (+row['changePrice'] === 0 || row['changePrice'] === '' || row['changePrice'] == null) { // 合价修改满足条件
      //   row['status'] = 0 // 状态改为0
      //   row['donePrice'] = '' // 调整后合价(不含税)
      //   row['changePrice'] = lastCount || (+row['changePrice']) // 变化合价
      //   row['donePrice'] = (+row['donePrice']) // 调整后合价(不含税)
      // } else if (!(row['changePrice'] === '' || +row['changePrice'] === 0)) {
      //   row['status'] = 1 // 状态
      //   // 2-调增合价；3-调减合价
      //   if (row['changePrice'] > 0) {
      //     row['changeStatus'] = '2'
      //   } else {
      //     row['changeStatus'] = '3'
      //   }
      //   // 20181217如果变化了合价，变化后数量与变化数量都不变取原来amount
      //   row['doneNum'] = row['amount'] // 重新赋值
      //   row['changNum'] = row['amount']// 重新赋值
      //   row['changePrice'] = (+row['changePrice'])// 重新赋值
      //   row['donePrice'] = donePrice1 // 重新赋值
      //   row['doneNum'] = (+row['doneNum'])// 重新赋值
      //   row['changeNum'] = (+row['changeNum'])// 重新赋值
      // } else {
      //   console.log('')
      // }
    },
    optimizeNewUpUsableStorageOne(row) {
      return +row['usableStorage'] === 0 || row['usableStorage'] === '' || row['usableStorage'] == null
    },
    optimizeNewUpUsableStorageTwo(row) {
      return !(row['doneNum'] === '' || row['doneNum'] == null)
    },
    optimizeNewUpUsableStorageThree(row) {
      return row['doneNum'] === '' || row['doneNum'] == null
    },
    optimizeNewUpUsableStorageFour(row) {
      let usableStorage = row['usableStorage']
      if (row['usableStorage'] === '' || row['usableStorage'] == null) {
        usableStorage = 0
      }
      return usableStorage
    },
    optimizeNewUpUsableStorageFive(row) {
      let usableStorage = row['unUsableStorage']
      if (row['unUsableStorage'] === '' || row['unUsableStorage'] == null) {
        usableStorage = ''
      }
      return usableStorage
    },
    optimizeNewUpUsableStorageSix(row) {
      let notUsableStorage = row['notUsableStorage']
      if (row['notUsableStorage'] === '' || row['notUsableStorage'] == null) {
        notUsableStorage = ''
            }
            return notUsableStorage
    },
    optimizeNewUpUsableStorageSeven(row) {
      let notUnusableStorage = row['notUnusableStorage']
      if (row['notUnusableStorage'] === '' || row['notUnusableStorage'] == null) {
          notUnusableStorage = ''
     }
            return notUnusableStorage
    },
    optimizeNewUpUsableStorageEight(row) {
      return row['taxRate'] === '' || row['taxRate'] == null
    },
    optimizeNewUpUsableStorageNine(row) {
      return row['doneNum'] === '' || row['doneNum'] == null
    },
    // 维护改造类2021.11.11 修复阻断
   async optimizeWHupdateUsableStorageOne(row, sumNum) {
     if (sumNum > 0) {
       // 调整后合价(不含税)
       row['donePrice'] = parseFloat(doneNum1) * parseFloat(row['price'])
       // 合价(不含税)
       if (row['equipSum'] == null) {
         row['equipSum'] = 0 // 合价(不含税)
       }
       // 判断税率
       if (this.optimizeNewUpUsableStorageEight(row)) {
         row['taxRate'] = 0 // 税率
       }
       // 变化合价
       row['changePrice'] = (parseFloat(row['donePrice']) - parseFloat(row['equipSum'])).toFixed(2)
       // 调整后税额(元)
       row['doneTaxAmount'] = (parseFloat(row['donePrice']) * parseFloat(row['taxRate'])).toFixed(2)
       // 调整后含税总价(元)
       row['doneAmt'] = (parseFloat(row['donePrice']) + parseFloat(row['doneTaxAmount'])).toFixed(2)
       // 入库可用
       row['usableStorage'] = (+row['usableStorage']) === 0 ? '' : (+row['usableStorage'])
     } else {
       row['status'] = 0 // 状态改为0
       row['doneNum'] = '' // 变化后数量
       row['donePrice'] = '' // 变化后合价
       row['changePrice'] = '' // 变化合价
       row['changeStatus'] = '' // 状态
       row['doneAmt'] = '' // 调整后含税总价(元)
       row['doneTaxAmount'] = '' // 调整后税额(元)
       row['usableStorage'] = '' // 入库可用
     }
   },
   async optimizeWHupdateUsableStorageTwo(row, doneNum1, lastCount) {
     // 如果不满足条件则提示消息
     if (doneNum1 < 0) {
       // 提示消息
       Message({
         message: `变化后数量”的计算结果不能为负数！`,
         type: 'warning'
       })
       // 入库可用
       row['usableStorage'] = this.optimizeNewUpUnusableStorageNine(lastCount)
     } else {
       this.checkUsableStorageNum(row,doneNum1)
     }
   },
    checkUsableStorageNum(row,doneNum1){
        //满足利旧
        if(+row.outPutType === 25 && +row.powerCable === 1){
            if(+row.usableStorage === row.amount && [null,0,''].includes(row.unUsableStorage) && [null,0,''].includes(row.notUsableStorage) && [null,0,''].includes(row.notUnusableStorage)){
                this.changeUsableStorageNum(row,doneNum1)
            }else{
                Message({
                    message: `采购订单号`+row.orderNo+`物资为利旧类电缆，仅允许选择一个有无实物下的退库类型将出库单数量整单退库！`,
                    type: 'warning'
                })
                row['status'] = 0 // 状态改为0
                row['doneNum'] = '' // 变化后数量
                row['donePrice'] = '' // 变化后合价
                row['changePrice'] = '' // 变化合价
                row['changeStatus'] = '' // 状态
                row['doneAmt'] = '' // 调整后含税总价(元)
                row['doneTaxAmount'] = '' // 调整后税额(元)
                row['usableStorage'] = '' // 入库可用
            }
        }else{
            this.changeUsableStorageNum(row,doneNum1)
        }
    },
   async optimizeWHupdateUsableStorageThree(row, doneNum1) {
     let backdoneNum1 = doneNum1
     // 变化后数量逻辑判断
     if (this.optimizeNewUpUsableStorageNine(row)) {
       // 给上面初始化变量赋值
       backdoneNum1 = parseFloat(row['amount']) - Number(parseFloat(row['usableStorage']))
     } else {
       // 入库可用赋值
       row['usableStorage'] = this.optimizeNewUpUsableStorageFour(row)
       // 入库不可用赋值
       row['unUsableStorage'] = this.optimizeNewUpUsableStorageFive(row)
       // 不入库可用赋值
       row['notUsableStorage'] = this.optimizeNewUpUsableStorageSix(row)
       // 不入库不可用赋值
       row['notUnusableStorage'] = this.optimizeNewUpUsableStorageSeven(row)
       // 重新赋值上面定义的变量
       backdoneNum1 = parseFloat(+row['amount']) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
     }
     return backdoneNum1
   },
    // 物资明细校验 - 入库可用
   async updateUsableStorage(row, lastCount) {
      // 定义一个初始化变量
      let doneNum1 = ''
      //   // 定义一个初始化变量
      let sumNum = 0
      // 判断入库可用的逻辑
      if (this.optimizeNewUpUsableStorageOne(row)) {
        if (this.optimizeNewUpUsableStorageTwo(row)) {
          row['usableStorage'] = 0 // 入库可用0
          if (this.optimizeNewUpUsableStorageThree(row)) {
            // 赋值给上面定义的变量
            doneNum1 = parseFloat(row['amount']) - Number(parseFloat(row['usableStorage']))
          } else {
            // 给入库可用重新赋值
            row['usableStorage'] = this.optimizeNewUpUsableStorageFour(row)
            // 给入库不可用重新赋值
            row['unUsableStorage'] = this.optimizeNewUpUsableStorageFive(row)
            // 给不入库可用重新赋值
            row['notUsableStorage'] = this.optimizeNewUpUsableStorageSix(row)
            // 给不入库不可用重新赋值
            row['notUnusableStorage'] = this.optimizeNewUpUsableStorageSeven(row)
            // 给上面定义的变量重新赋值
            sumNum = parseFloat(this.defaultZero(+row['usableStorage'])) + parseFloat(this.defaultZero(+row['unUsableStorage'])) + parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            // 给上面定义的变量重新赋值
            doneNum1 = parseFloat(+row['amount']) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
          }
          // 判断是否大于0
          await this.optimizeWHupdateUsableStorageOne(row, sumNum)
        } else {
          row['status'] = 0 // 状态改为0
          row['doneNum'] = ''// 变化后数量
          row['donePrice'] = ''// 变化后合价
          row['changePrice'] = '' // 变化合价
          row['changeStatus'] = ''// 状态
          row['doneAmt'] = ''// 调整后含税总价(元)
          row['doneTaxAmount'] = ''// 调整后税额(元)
          row['usableStorage'] = ''// 入库可用
        }
      } else {
        doneNum1 = await this.optimizeWHupdateUsableStorageThree(row, doneNum1)
        await this.optimizeWHupdateUsableStorageTwo(row, doneNum1, lastCount)
      }
    },
     changeUsableStorageNum(row,doneNum1){
        row['status'] = 1 // 状态
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = '1'
        // 0.99 26.55 26.2845 变化后合价
        row['donePrice'] = parseFloat(+doneNum1) * parseFloat(+row['price'])
        // 合价(不含税)
        if (row['equipSum'] == null) {
            // 合价(不含税)赋值
            row['equipSum'] = 0
        }
        // 税率
        if (this.optimizeNewUpUsableStorageEight(row)) {
            // 税率赋值
            row['taxRate'] = 0
        }
        // 调整合价(不含税)
        row['changePrice'] = parseFloat(+row['donePrice']) - parseFloat(+row['equipSum'])
        // 调整后税额(元)
        row['doneTaxAmount'] = parseFloat(+row['donePrice']) * parseFloat(+row['taxRate'])
        // 调整后含税总价(元)
        row['doneAmt'] = parseFloat(+row['donePrice']) + parseFloat(+row['doneTaxAmount'])
        // 赋值如可可用
        row['usableStorage'] = (+row['usableStorage'])
        // 变化后数量
        row['doneNum'] = doneNum1
        // 调整合价(不含税)
        row['changePrice'] = (+row['changePrice']).toFixed(2)
        // 变化后合价
        row['donePrice'] = (+row['donePrice']).toFixed(2)
        // 调整后含税总价(元)
        row['doneAmt'] = (+row['doneAmt']).toFixed(2)
        // 调整后税额(元)
        row['doneTaxAmount'] = (+row['doneTaxAmount']).toFixed(2)
    },
    optimizeNewUpUnusableStorageOne(unUsableStorage) {
      return +unUsableStorage === 0 || unUsableStorage === '' || unUsableStorage == null
    },
    optimizeNewUpUnusableStorageTwo(doneNum) {
      return !(doneNum === '' || doneNum == null)
    },
    optimizeNewUpUnusableStorageThree(doneNum) {
      return doneNum === '' || doneNum == null
    },
    optimizeNewUpUnusableStorageFour(row, usableStorage) {
      let _usableStorage = row['usableStorage']
      if (usableStorage === '' || usableStorage == null) {
        _usableStorage = '' // 重新赋值
       }
      return _usableStorage
    },
    optimizeNewUpUnusableStorageFive(row, unUsableStorage) {
      let _unUsableStorage = row['unUsableStorage']
      if (unUsableStorage === '' || unUsableStorage == null) {
        _unUsableStorage = 0 // 重新赋值
       }
      return _unUsableStorage
    },
    optimizeNewUpUnusableStorageSix(row, notUsableStorage) {
      let _notUsableStorage = row['notUsableStorage']
      if (notUsableStorage === '' || notUsableStorage == null) {
        _notUsableStorage = '' // 重新赋值
       }
      return _notUsableStorage
    },
    optimizeNewUpUnusableStorageSeven(row, notUnusableStorage) {
      let _notUnusableStorage = row['notUnusableStorage']
      if (notUnusableStorage === '' || notUnusableStorage == null) {
        _notUnusableStorage = '' // 重新赋值
       }
      return _notUnusableStorage
    },
    optimizeNewUpUnusableStorageEight(taxRate) {
      return taxRate === '' || taxRate == null
    },
    optimizeNewUpUnusableStorageNine(lastCount) {
      return lastCount || ''
    },
    // 维护改造类2021.11.11 修复阻断
    async optimizeWHupdateUnusableStorageOne(doneNum1, doneNum, amount, row, usableStorage, unUsableStorage, notUsableStorage, notUnusableStorage) {
      let backdoneNum1 = doneNum1
      // 变化后数量符合条件
      if (this.optimizeNewUpUnusableStorageThree(doneNum)) {
        // 初始化定义变量赋值
        backdoneNum1 = parseFloat(amount) - Number(parseFloat(unUsableStorage))
      } else {
        // 如果入库可用满足条件
        row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage)// 重新赋值
        // 如果入库不可用满足条件
        row['unUsableStorage'] = this.optimizeNewUpUnusableStorageFive(row, unUsableStorage) // 重新赋值
        // 如果不入库可用满足条件
        row['notUsableStorage'] = this.optimizeNewUpUnusableStorageSix(row, notUsableStorage)// 重新赋值
        // 如果不入库不可用满足条件
        row['notUnusableStorage'] = this.optimizeNewUpUnusableStorageSeven(row, notUnusableStorage)// 重新赋值
        // 给上面定义的变量赋值
        backdoneNum1 = parseFloat(+row['amount']) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
      }
      return backdoneNum1
    },
    async optimizeWHupdateUnusableStorageTwo(doneNum1, row, lastCount, price, equipSum, taxRate) {
      // 判断如果符合条件进入逻辑判断
      if (doneNum1 < 0) {
          // 提示消息
          Message({
            message: `变化后数量”的计算结果不能为负数！`,
            type: 'warning'
          })
          // 不入库可用
          row['unUsableStorage'] = this.optimizeNewUpUnusableStorageNine(lastCount)
        } else {
          this.checkUnusableStorageNum(doneNum1, row, lastCount, price, equipSum, taxRate);
        }
    },
    checkUnusableStorageNum(doneNum1, row, lastCount, price, equipSum, taxRate){
        //满足利旧
        if(+row.outPutType === 25 && +row.powerCable === 1){
            if(+row.unUsableStorage === row.amount && [null,0,''].includes(row.usableStorage) && [null,0,''].includes(row.notUsableStorage) && [null,0,''].includes(row.notUnusableStorage)){
                this.changeUnusableStorageNum(doneNum1, row, lastCount, price, equipSum, taxRate);
            }else{
                Message({
                    message: `采购订单号`+row.orderNo+`物资为利旧类电缆，仅允许选择一个有无实物下的退库类型将出库单数量整单退库！`,
                    type: 'warning'
                })
                row['status'] = 0 // 状态改变
                row['doneNum'] = '' // 变化后数量
                row['donePrice'] = '' // 变化后合价
                row['changePrice'] = '' // 变化合价
                row['changeStatus'] = '' // 状态
                row['doneAmt'] = '' // 调整后含税总价(元)
                row['doneTaxAmount'] = ''// 调整后税额(元)
                row['unUsableStorage'] = ''// 入库不可用
            }
        }else{
            this.changeUnusableStorageNum(doneNum1, row, lastCount, price, equipSum, taxRate);
        }
    },
    async optimizeWHupdateUnusableStorageThree(sumNum, row, doneNum1, price, equipSum, taxRate, donePrice, doneTaxAmount) {
      // 判断如果符合条件进入逻辑判断
      if (sumNum > 0) {
        // 调整后合价(不含税)
        row['donePrice'] = parseFloat(doneNum1) * parseFloat(price)
        // 合价(不含税)
        if (equipSum == null) {
          // 合价(不含税) 赋值
          row['equipSum'] = 0
        }
        // 变化合价
        row['changePrice'] = (parseFloat(donePrice) - parseFloat(equipSum)).toFixed(2)
        // 调整后税额(元)
        row['doneTaxAmount'] = (parseFloat(donePrice) * parseFloat(taxRate)).toFixed(2)
        // 调整后含税总价(元)
        row['doneAmt'] = (parseFloat(donePrice) + parseFloat(doneTaxAmount)).toFixed(2)
        // 入库不可用
        row['unUsableStorage'] = (+row['unUsableStorage']) === 0 ? '' : (+row['unUsableStorage'])
      } else {
        row['status'] = 0 // 状态改变
        row['doneNum'] = '' // 变化后数量
        row['donePrice'] = '' // 变化后合价
        row['changePrice'] = '' // 变化合价
        row['changeStatus'] = '' // 状态
        row['doneAmt'] = '' // 调整后含税总价(元)
        row['doneTaxAmount'] = ''// 调整后税额(元)
        row['unUsableStorage'] = ''// 入库不可用
      }
    },
    // 物资明细校验 - 入库不可用
   async updateUnusableStorage(row, lastCount) {
      // 初始化定义变量
      let doneNum1 = ''
      // 初始化定义变量
      let sumNum = 0
      const { usableStorage, unUsableStorage, notUsableStorage, notUnusableStorage, donePrice, price, doneNum, equipSum, amount, taxRate, doneTaxAmount } = row
      //    如果入库可用满足三个条件中的第一个
      if (this.optimizeNewUpUnusableStorageOne(unUsableStorage)) {
        // 调整后数量如果满足
        if (this.optimizeNewUpUnusableStorageTwo(doneNum)) {
          // 入库可用赋值
          row['unUsableStorage'] = 0
          // 调整后数量如果满足
          if (this.optimizeNewUpUnusableStorageThree(doneNum)) {
            // 重新赋值定义的初始化变量
            doneNum1 = parseFloat(amount) - Number(parseFloat(unUsableStorage))
          } else {
            // 如果入库可用满足条件
            row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage) // 重新赋值
            // 如果入库不可用满足条件
            row['unUsableStorage'] = this.optimizeNewUpUnusableStorageFive(row, unUsableStorage) // 重新赋值
            // 如果不入库可用满足条件
            row['notUsableStorage'] = this.optimizeNewUpUnusableStorageSix(row, notUsableStorage) // 重新赋值
            // 如果不入库不可用满足条件
            row['notUnusableStorage'] = this.optimizeNewUpUnusableStorageSeven(row, notUnusableStorage) // 重新赋值
            // 给上面定义的变量赋值 sumNum  doneNum1
            sumNum = parseFloat(this.defaultZero(+row['usableStorage'])) + parseFloat(this.defaultZero(+row['unUsableStorage'])) + parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            doneNum1 = parseFloat(+amount) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
          }
          await this.optimizeWHupdateUnusableStorageThree(sumNum, row, doneNum1, price, equipSum, taxRate, donePrice, doneTaxAmount)
        } else {
          row['status'] = 0 // 状态改变
          row['doneNum'] = '' // 变化后数量
          row['donePrice'] = '' // 变化后合价
          row['changePrice'] = '' // 变化合价
          row['changeStatus'] = '' // 状态
          row['doneAmt'] = '' // 调整后含税总价(元)
          row['doneTaxAmount'] = ''// 调整后税额(元)
          row['unUsableStorage'] = ''// 入库不可用
        }
      } else {
        doneNum1 = await this.optimizeWHupdateUnusableStorageOne(doneNum1, doneNum, amount, row, usableStorage, unUsableStorage, notUsableStorage, notUnusableStorage)
        await this.optimizeWHupdateUnusableStorageTwo(doneNum1, row, lastCount, price, equipSum, taxRate)
      }
    },
    changeUnusableStorageNum(doneNum1, row, lastCount, price, equipSum, taxRate){
        row['status'] = 1 // 状态
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = '1' // 状态
        // 变化后合价
        row['donePrice'] = parseFloat(+doneNum1) * parseFloat(+price)
        // 合价(不含税)
        if (equipSum == null) {
            row['equipSum'] = 0 // 合价(不含税)赋值
        }
        // 税率
        if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
            row['taxRate'] = 0 // 税率赋值
        }
        // 调整合价(不含税)
        row['changePrice'] = parseFloat(+row['donePrice']) - parseFloat(+row['equipSum'])
        // 调整后税额(元)
        row['doneTaxAmount'] = parseFloat(+row['donePrice']) * parseFloat(+row['taxRate'])
        // 调整后含税总价(元)
        row['doneAmt'] = parseFloat(+row['donePrice']) + parseFloat(+row['doneTaxAmount'])
        // 不入库可用
        row['unUsableStorage'] = (+row['unUsableStorage'])
        // 变化后数量
        row['doneNum'] = doneNum1
        // // 调整合价(不含税)
        row['changePrice'] = (+row['changePrice']).toFixed(2)
        // 变化后合价
        row['donePrice'] = (+row['donePrice']).toFixed(2)
        // 调整后含税总价(元)
        row['doneAmt'] = (+row['doneAmt']).toFixed(2)
        // 调整后税额(元)
        row['doneTaxAmount'] = (+row['doneTaxAmount']).toFixed(2)
    },
    optimizeNewUpNotUsableStorageOne(notUsableStorage) {
      return +notUsableStorage === 0 || notUsableStorage === '' || notUsableStorage == null
    },
    optimizeNewUpNotUsableStorageTwo(row, unUsableStorage) {
      let _unUsableStorage = row['unUsableStorage']
      if (unUsableStorage === '' || unUsableStorage == null) {
        _unUsableStorage = '' // 重新赋值
       }
      return _unUsableStorage
    },
    optimizeNewUpNotUsableStorageThree(row, notUsableStorage) {
      let _notUsableStorage = row['notUsableStorage']
      if (notUsableStorage === '' || notUsableStorage == null) {
        _notUsableStorage = 0 // 重新赋值
       }
      return _notUsableStorage
    },
     // 维护改造类2021.11.11 修复阻断
   async optimizeWHupdateNotUsableStorageOne(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate) {
     // 判断如果符合条件进入逻辑判断
     if (doneNum1 < 0) {
       // 提示消息
       Message({
         message: `变化后数量”的计算结果不能为负数！`,
         type: 'warning'
       })
       // 不入库不可用赋值
       row['notUsableStorage'] = this.optimizeNewUpUnusableStorageNine(lastCount)
     } else {
       this.checkNotUsableStorageNum(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate)
     }
   },
    checkNotUsableStorageNum(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate){
        //满足利旧
        if(+row.outPutType === 25 && +row.powerCable === 1){
            if(+row.notUsableStorage === row.amount && [null,0,''].includes(row.usableStorage) && [null,0,''].includes(row.unUsableStorage) && [null,0,''].includes(row.notUnusableStorage)){
                this.changeNotUsableStorageNum(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate)
            }else{
                Message({
                    message: `采购订单号`+row.orderNo+`物资为利旧类电缆，仅允许选择一个有无实物下的退库类型将出库单数量整单退库！`,
                    type: 'warning'
                })
                row['status'] = 0 // 状态改变
                row['doneNum'] = '' // 变化后数量
                row['donePrice'] = '' // 变化后合价
                row['changePrice'] = '' // 变化合价
                row['changeStatus'] = '' // 状态
                row['doneAmt'] = '' // 调整后含税总价(元)
                row['doneTaxAmount'] = '' // 调整后税额(元)
                row['notUsableStorage'] = ''// 不入库可用
                row['storeManName'] = '' // 保管人
                row['storeManNum'] = ''// 保管人联系方式
                row['storageAddress'] = '' // 实物保管地址
            }
        }else{
            this.changeNotUsableStorageNum(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate)
        }
    },
   async optimizeWHupdateNotUsableStorageTwo(row, doneNum, doneNum1, amount, notUsableStorage, usableStorage, unUsableStorage, notUnusableStorage) {
    let backdoneNum1 = doneNum1
     // 变化后数量满足条件
     if (doneNum === '' || doneNum == null) {
       // 重新赋值初始化定义的变量
       backdoneNum1 = (parseFloat(amount) - Number(parseFloat(notUsableStorage)))
     } else {
       // 如果入库可用满足条件
       row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage)// 重新赋值
       // 如果入库不可用满足条件
       row['unUsableStorage'] = this.optimizeNewUpNotUsableStorageTwo(row, unUsableStorage) // 重新赋值
       // 如果不入库可用满足条件
       row['notUsableStorage'] = this.optimizeNewUpNotUsableStorageThree(row, notUsableStorage) // 重新赋值
       // 如果不入库不可用满足条件
       row['notUnusableStorage'] = this.optimizeNewUpUnusableStorageSeven(row, notUnusableStorage) // 重新赋值
       // 给上面定义的变量赋值 sumNum  doneNum1
       backdoneNum1 = parseFloat(row['amount']) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
     }
     return backdoneNum1
   },
   async optimizeWHupdateNotUsableStorageThree(row, sumNum, doneNum1, price, equipSum, taxRate, notSunNum, donePrice, doneTaxAmount) {
     // 判断如果符合条件进入逻辑判断
     if (sumNum > 0) {
       // 变化后合价
       row['donePrice'] = parseFloat(doneNum1) * parseFloat(price)
       // 合价(不含税)是否满足条件
       if (equipSum == null) {
         // 合价(不含税)赋值
         row['equipSum'] = 0
       }
       // 税率是否满足条件
       if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
         // 税率赋值
         row['taxRate'] = 0
       }
       // 如果“不入库”字段已经填写数据，保管人字段不清空，否则清空
       if (!(notSunNum > 0)) {
         // 保管人字段清空
         row['storeManName'] = ''
       }
       // 调整合价(不含税)
       row['changePrice'] = (parseFloat(donePrice) - parseFloat(equipSum)).toFixed(2)
       // 调整后税额
       row['doneTaxAmount'] = (parseFloat(donePrice) * parseFloat(taxRate)).toFixed(2)
       //   调整后含税总价
       row['doneAmt'] = (parseFloat(donePrice) + parseFloat(doneTaxAmount)).toFixed(2)
       //    不入库可用
       row['notUsableStorage'] = (+row['notUsableStorage']) === 0 ? '' : (+row['notUsableStorage'])
     } else {
       row['status'] = 0 // 状态改变
       row['doneNum'] = '' // 变化后数量
       row['donePrice'] = '' // 变化后合价
       row['changePrice'] = '' // 变化合价
       row['changeStatus'] = '' // 状态
       row['doneAmt'] = '' // 调整后含税总价(元)
       row['doneTaxAmount'] = '' // 调整后税额(元)
       row['notUsableStorage'] = ''// 不入库可用
       row['storeManName'] = '' // 保管人
       row['storeManNum'] = ''// 保管人联系方式
       row['storageAddress'] = '' // 实物保管地址
     }
   },
    // 物资明细校验 - 不入库可用
   async updateNotUsableStorage(row, lastCount) {
      // 定义初始化变量
      let doneNum1 = ''
      // 定义初始化变量
      let sumNum = 0
      let notSunNum = 0// 记录“不入库（不可用不入库、可用不入库）”字段是否填写
      const { usableStorage, unUsableStorage, notUsableStorage, notUnusableStorage, fieldProjectManager, donePrice, price, doneNum, equipSum, amount, taxRate, doneTaxAmount } = row
      // 判断不入库可用是否满足条件
      if (this.optimizeNewUpNotUsableStorageOne(notUsableStorage)) {
        // 变化后数量如果满足条件进入
        if (this.optimizeNewUpUnusableStorageTwo(doneNum)) {
          row['notUsableStorage'] = 0 // 不入库可用赋值
          // 变化后数量如果满足条件进入
          if (this.optimizeNewUpUnusableStorageThree(doneNum)) {
            // 将初始化变量的 值重新赋值
            doneNum1 = Number(parseFloat(+row['amount'])) - Number(parseFloat(+row['notUsableStorage']))
          } else {
            // 如果入库可用满足条件
            row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage)// 重新赋值
            // 如果入库不可用满足条件
            row['unUsableStorage'] = this.optimizeNewUpNotUsableStorageTwo(row, unUsableStorage) // 重新赋值
            // 如果不入库可用满足条件
            row['notUsableStorage'] = this.optimizeNewUpNotUsableStorageThree(row, notUsableStorage) // 重新赋值
            // 如果不入库不可用满足条件
            row['notUnusableStorage'] = this.optimizeNewUpUnusableStorageSeven(row, notUnusableStorage) // 重新赋值
            // 给上面定义的变量赋值
            sumNum = parseFloat(this.defaultZero(+row['usableStorage'])) + parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            notSunNum = parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            doneNum1 = parseFloat(+amount) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
          }
          await this.optimizeWHupdateNotUsableStorageThree(row, sumNum, doneNum1, price, equipSum, taxRate, notSunNum, donePrice, doneTaxAmount)
        } else {
          row['status'] = 0 // 状态改变
          row['doneNum'] = '' // 变化后数量
          row['donePrice'] = '' // 变化后合价
          row['changePrice'] = '' // 变化合价
          row['changeStatus'] = '' // 状态
          row['doneAmt'] = '' // 调整后含税总价(元)
          row['doneTaxAmount'] = '' // 调整后税额(元)
          row['notUsableStorage'] = ''// 不入库可用
          row['storeManName'] = '' // 保管人
          row['storeManNum'] = ''// 保管人联系方式
          row['storageAddress'] = '' // 实物保管地址
        }
      } else {
        doneNum1 = await this.optimizeWHupdateNotUsableStorageTwo(row, doneNum, doneNum1, amount, notUsableStorage, usableStorage, unUsableStorage, notUnusableStorage)
        await this.optimizeWHupdateNotUsableStorageOne(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate)
      }
    },
    changeNotUsableStorageNum(row, doneNum1, fieldProjectManager, lastCount, equipSum, taxRate){
        row['status'] = 1 // 状态赋值
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = '1'
        // 变化后合价
        row['donePrice'] = parseFloat(+doneNum1) * parseFloat(row['price'])
        // 合价(不含税) 满足条件
        if (equipSum == null) {
            // 合价(不含税)赋值
            row['equipSum'] = 0
        }
        // 税率满足条件
        if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
            // 税率赋值
            row['taxRate'] = 0
        }
        // 变化合价
        row['changePrice'] = parseFloat(row['donePrice']) - parseFloat(row['equipSum'])
        // 调整后税额
        row['doneTaxAmount'] = parseFloat(row['donePrice']) * parseFloat(row['taxRate'])
        //    调整后含税总价
        row['doneAmt'] = parseFloat(row['donePrice']) + parseFloat(row['doneTaxAmount'])
        // 当项目管理岗不为空并且保管人没有填写，保管人默认取项目管理岗用户
        if (fieldProjectManager !== '1') {
            // 保管人赋值
            row['storeManName'] = fieldProjectManager
        }
        // 保管人赋值
        row['storemanName'] = (row['storemanName'] + '')
        // 不入库可用赋值
        row['notUsableStorage'] = (+row['notUsableStorage'])
        // 变化后数量
        row['doneNum'] = doneNum1
        // 变化合价
        row['changePrice'] = (+row['changePrice']).toFixed(2)
        // 变化后合价
        row['donePrice'] = (+row['donePrice']).toFixed(2)
        // 调整后含税总价
        row['doneAmt'] = (+row['doneAmt']).toFixed(2)
        // 调整后税额
        row['doneTaxAmount'] = (+row['doneTaxAmount']).toFixed(2)
    },
    optimizeNewUpNotUNusableStorageOne(notUnusableStorage) {
      return +notUnusableStorage === 0 || notUnusableStorage === '' || notUnusableStorage == null
    },
    optimizeNewUpNotUNusableStorageTwo(row, notUnusableStorage) {
      let _notUnusableStorage = row['notUnusableStorage']
      if (notUnusableStorage === '' || notUnusableStorage == null) {
        _notUnusableStorage = 0 // 重新赋值
       }
      return _notUnusableStorage
    },
    // 物资明细校验 - 不入库不可用
    // 维护改造类2021.11.11 修复阻断
   async optimizeWHupdateNotUNusableStorageeOne(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager) {
    // 判断如果符合条件进入逻辑判断
     if (doneNum1 < 0) {
       // 提示消息
       Message({
         message: `变化后数量”的计算结果不能为负数！`,
         type: 'warning'
       })
       // 不入库可用
       row['notUnusableStorage'] = this.optimizeNewUpUnusableStorageNine(lastCount)
     } else {
         this.checkNotUNusableStorageNum(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager);
     }
   },
   checkNotUNusableStorageNum(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager){
       //满足利旧
       if(+row.outPutType === 25 && +row.powerCable === 1){
           if(+row.notUnusableStorage === row.amount && [null,0,''].includes(row.usableStorage) && [null,0,''].includes(row.unUsableStorage) && [null,0,''].includes(row.notUsableStorage)){
               this.changeNotUNusableStorageNum(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager);
           }else{
               Message({
                   message: `采购订单号`+row.orderNo+`物资为利旧类电缆，仅允许选择一个有无实物下的退库类型将出库单数量整单退库！`,
                   type: 'warning'
               })
               row['status'] = 0 // 状态改变
               row['doneNum'] = '' // 变化后数量
               row['donePrice'] = '' // 变化后合价
               row['changePrice'] = '' // 变化合价
               row['changeStatus'] = '' // 状态
               row['doneAmt'] = '' // 调整后含税总价(元)
               row['doneTaxAmount'] = '' // 调整后税额(元)
               row['notUnusableStorage'] = '' // 不入库不可用赋值
               row['storeManName'] = '' // 保管人
               row['storeManNum'] = ''// 保管人联系方式
               row['storageAddress'] = '' // 实物保管地址
           }
       }else{
           this.changeNotUNusableStorageNum(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager);
       }
   },
   async optimizeWHupdateNotUNusableStorageTwo(row, doneNum1, doneNum, amount, notUnusableStorage, usableStorage, unUsableStorage, notUsableStorage) {
    let backdoneNum1 = doneNum1
     // 变化后数量符合条件
     if (this.optimizeNewUpUnusableStorageThree(doneNum)) {
       // 初始化定义变量赋值
       backdoneNum1 = parseFloat(amount) - Number(parseFloat(notUnusableStorage))
     } else {
       // 如果入库可用满足条件
       row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage)// 重新赋值
       // 如果入库不可用满足条件
       row['unUsableStorage'] = this.optimizeNewUpNotUsableStorageTwo(row, unUsableStorage)// 重新赋值
       // 如果不入库可用满足条件
       row['notUsableStorage'] = this.optimizeNewUpUnusableStorageSix(row, notUsableStorage)// 重新赋值
       // 如果不入库不可用满足条件
       row['notUnusableStorage'] = this.optimizeNewUpNotUNusableStorageTwo(row, notUnusableStorage)// 重新赋值
       // 给上面定义的变量赋值
       backdoneNum1 = parseFloat(+row['amount']) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
     }
     return backdoneNum1
   },
   async optimizeWHupdateNotUNusableStorageThree(row, sumNum, doneNum1, price, equipSum, taxRate, notSunNum, donePrice, doneTaxAmount) {
     // 判断如果符合条件进入逻辑判断
     if (sumNum > 0) {
       // 调整后合价(不含税)
       row['donePrice'] = parseFloat(doneNum1) * parseFloat(price)
       // 合价(不含税)
       if (equipSum == null) {
         // 合价(不含税) 赋值
         row['equipSum'] = 0
       }
       // 税率是否满足跳进啊
       if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
         // 税率赋值
         row['taxRate'] = 0
       }
       // 如果“不入库”字段已经填写数据，保管人字段不清空，否则清空
       if (!(notSunNum > 0)) {
         row['storemanName'] = '' // 保管人字段清空
       }
       // 变化合价赋值
       row['changePrice'] = (parseFloat(donePrice) - parseFloat(equipSum)).toFixed(2)
       //    调整后税额
       row['doneTaxAmount'] = (parseFloat(donePrice) * parseFloat(taxRate)).toFixed(2)
       // 调整后含税总价
       row['doneAmt'] = (parseFloat(donePrice) + parseFloat(doneTaxAmount)).toFixed(2)
       // 不入库不可用
       row['notUnusableStorage'] = (+row['notUnusableStorage']) === 0 ? '' : (+row['notUnusableStorage'])
     } else {
       row['status'] = 0 // 状态改变
       row['doneNum'] = '' // 变化后数量
       row['donePrice'] = '' // 变化后合价
       row['changePrice'] = '' // 变化合价
       row['changeStatus'] = '' // 状态
       row['doneAmt'] = '' // 调整后含税总价(元)
       row['doneTaxAmount'] = '' // 调整后税额(元)
       row['notUnusableStorage'] = '' // 不入库不可用赋值
       row['storeManName'] = '' // 保管人
       row['storeManNum'] = ''// 保管人联系方式
       row['storageAddress'] = '' // 实物保管地址
     }
   },
   async updateNotUNusableStorage(row, lastCount) {
      // 初始定义变量
      let doneNum1 = ''
      // 初始定义变量
      let sumNum = 0
      // 初始定义变量
      let notSunNum = 0// 记录“不入库（不可用不入库、可用不入库）”字段是否填写
      const { fieldProjectManager, usableStorage, unUsableStorage, notUsableStorage, notUnusableStorage, donePrice, price, doneNum, equipSum, amount, taxRate, doneTaxAmount } = row
      //    如果不入库不可用满足条件进入
      if (this.optimizeNewUpNotUNusableStorageOne(notUnusableStorage)) {
        //    变化后数量是否满足条件
        if (this.optimizeNewUpUnusableStorageTwo(doneNum)) {
          // 不入库不可用赋值
          row['notUnusableStorage'] = 0
          //   变化后数量是否满足条件
          if (this.optimizeNewUpUnusableStorageThree(doneNum)) {
            // 初始化变量赋值
            doneNum1 = parseFloat(amount) - Number(parseFloat(notUnusableStorage))
          } else {
            // 如果入库可用满足条件
            row['usableStorage'] = this.optimizeNewUpUnusableStorageFour(row, usableStorage) // 重新赋值
            // 如果入库不可用满足条件
            row['unUsableStorage'] = this.optimizeNewUpNotUsableStorageTwo(row, unUsableStorage) // 重新赋值
            // 如果不入库可用满足条件
            row['notUsableStorage'] = this.optimizeNewUpUnusableStorageSix(row, notUsableStorage) // 重新赋值
            // 如果不入库不可用满足条件
            row['notUnusableStorage'] = this.optimizeNewUpNotUNusableStorageTwo(row, notUnusableStorage) // 重新赋值

            // 给上面定义的变量赋值 sumNum  notSunNum doneNum1
            sumNum = parseFloat(this.defaultZero(+row['usableStorage'])) + parseFloat(this.defaultZero(+row['unUsableStorage'])) + parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            notSunNum = parseFloat(this.defaultZero(+row['notUsableStorage'])) + parseFloat(this.defaultZero(+row['notUnusableStorage']))
            doneNum1 = parseFloat(+amount) - parseFloat(this.defaultZero(+row['usableStorage'])) - parseFloat(this.defaultZero(+row['unUsableStorage'])) - parseFloat(this.defaultZero(+row['notUsableStorage'])) - parseFloat(this.defaultZero(+row['notUnusableStorage']))
          }
          await this.optimizeWHupdateNotUNusableStorageThree(row, sumNum, doneNum1, price, equipSum, taxRate, notSunNum, donePrice, doneTaxAmount)
        } else {
          row['status'] = 0 // 状态改变
          row['doneNum'] = '' // 变化后数量
          row['donePrice'] = '' // 变化后合价
          row['changePrice'] = '' // 变化合价
          row['changeStatus'] = '' // 状态
          row['doneAmt'] = '' // 调整后含税总价(元)
          row['doneTaxAmount'] = '' // 调整后税额(元)
          row['notUnusableStorage'] = '' // 不入库不可用赋值
          row['storeManName'] = '' // 保管人
          row['storeManNum'] = ''// 保管人联系方式
          row['storageAddress'] = '' // 实物保管地址
        }
      } else {
        doneNum1 = await this.optimizeWHupdateNotUNusableStorageTwo(row, doneNum1, doneNum, amount, notUnusableStorage, usableStorage, unUsableStorage, notUsableStorage)
        await this.optimizeWHupdateNotUNusableStorageeOne(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager)
      }
    },
    changeNotUNusableStorageNum(row, doneNum1, lastCount, equipSum, taxRate, fieldProjectManager){
        row['status'] = 1 // 状态
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = '1' // 状态
        // 变化后合价
        row['donePrice'] = parseFloat(doneNum1) * parseFloat(row['price'])
        // 合价(不含税)
        if (equipSum === null) {
            row['equipSum'] = 0 // 合价(不含税)赋值
        }
        // 税率
        if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
            row['taxRate'] = 0 // 税率赋值
        }
        // 调整合价(不含税)
        row['changePrice'] = parseFloat(row['donePrice']) - parseFloat(row['equipSum'])
        // 调整后税额(元)
        row['doneTaxAmount'] = parseFloat(row['donePrice']) * parseFloat(row['taxRate'])
        // 调整后含税总价(元)
        row['doneAmt'] = parseFloat(row['donePrice']) + parseFloat(row['doneTaxAmount'])
        // 当项目管理岗不为空并且保管人没有填写，保管人默认取项目管理岗用户
        if (fieldProjectManager !== '1') {
            // 保管人赋值
            row['storeManName'] = fieldProjectManager
        }
        //    保管人
        row['storemanName'] = (row['storemanName'] + '')
        // 不入库不可用
        row['notUnusableStorage'] = (+row['notUnusableStorage'])
        // 变化后数量
        row['doneNum'] = doneNum1
        // // 调整合价(不含税)
        row['changePrice'] = (+row['changePrice']).toFixed(2)
        // 变化后合价
        row['donePrice'] = (+row['donePrice']).toFixed(2)
        // 调整后含税总价(元)
        row['doneAmt'] = (+row['doneAmt']).toFixed(2)
        // 调整后税额(元)
        row['doneTaxAmount'] = (+row['doneTaxAmount']).toFixed(2)
    },
    // 过滤需要保存的数据
    filterUpdataTableRow(tableData, allIndex, activeName) {
      // 深拷贝一份数据 保存的时候不应该带状态
      const _deepCopy = JSON.parse(JSON.stringify(tableData))
      let _filterData = [] // 初始化定义数组
      if (activeName === '物资明细信息') {
        // 如果是物资则走这个逻辑
        _filterData = _deepCopy.filter((_, index) => allIndex.includes(index))
      } else {
        // 去重数组中重复的id
        const uniqueIndex = allIndex.filter((value, index, self) => {
          return self.indexOf(value) === index
        })
        // 去重兵器拿到最新的数组
        const result = this.filterNodes(this.uniqueArrId(this.findObjectsByIds(_deepCopy, uniqueIndex)), uniqueIndex)
        // 数组赋值
        _filterData = this.mergeById(_deepCopy, result)
      }
      _filterData.forEach(item => {
        // // 考虑到服务商会存在子节点
        if (item.childNodeList && item.childNodeList.length > 0) {
          item.childNodeList.forEach(i => {
            // 删掉id，index
            delete i.id
            delete i.index
          })
        }
        // 删除前端添加的属性
        delete item.id
        delete item.index
      })
      // 返回数组
      return _filterData
    },
    mergeById(res1, res2) {
      // 遍历对象
      for (const item2 of res2) {
        // 查找符合条件元素
        const existingItemIndex = res1.findIndex(item1 => item1.id === item2.id)
        // 如果-1则没有找到则添加该属性
        if (existingItemIndex !== -1) {
          res1[existingItemIndex] = item2
        }
      }
      return res1
    },
    // 服务需要根据id查找
    findObjectsByIds(arr, targetIds) {
      // 初始化结果数组
      const result = []
      // 遍历输入数组 arr
      for (const obj of arr) {
        // 临时保存当前对象的 children
        const children = obj.childNodeList

        // 如果当前对象有 children 属性，则递归查找其子项
        if (Array.isArray(children)) {
          const childResults = this.findObjectsByIds(children, targetIds)

          // 如果在子项中找到了匹配的对象，则将整个子树（包括父对象及其 children）添加到结果数组
          if (childResults.length > 0) {
            result.push({
              ...obj,
              childNodeList: childResults
            })
          }
        }

        // 检查当前对象的 id 是否存在于目标 ID 数组中
        if (targetIds.includes(obj.id)) {
          // 若存在，则将当前对象添加到结果数组（无需处理 children，因为它们已经包含在子树中）
          result.push(obj)
        }
      }
      return result
    },
    // 数组去重 id
    uniqueArrId(arr) {
      return arr.reduce((acc, item) => {
        // 如果映射对象中不存在当前 item 的 id，则添加到结果数组和映射对象中
        if (!acc.map.has(item.id)) {
          acc.result.push(item)
          acc.map.set(item.id, true)
        }
        return acc
      }, { result: [], map: new Map() }).result
    },
    // 服务二次过滤数据
    filterNodes(arr, allId) {
      return arr.map((parentNode) => {
        // 首先map对当前数组的childNodeList进行遍历
        const filteredChildNodes = parentNode.childNodeList.filter(
          // 查找是否符合条件
          (childNode) => allId.includes(childNode.id)
        )

        // 检查是否包含任何子节点，或者父节点本身是否在列表中
        const hasIncludedChildOrParent = filteredChildNodes.length > 0 || allId.includes(parentNode.id)
        // 如果存在则返回
        if (hasIncludedChildOrParent) {
          // 如果不包括子节点，则返回具有筛选的子节点或空数组的父节点
          return {
            ...parentNode,
            childNodeList: filteredChildNodes.length ? filteredChildNodes : []
          }
        }
        // 如果既不包括父节点也不包括任何子节点，则返回undefined（将从最终结果中过滤掉）
        return undefined
      }).filter(Boolean)
    },
    // 保存的时候需要按照后端的处理格式 如果父节点变动children 没有变 则把children =[]
    filteredWithParents(res) {
      return res.map((parentItem) => {
        const { childNodeList } = parentItem
        if (childNodeList.every((child) => child.status === '0' || child.status == null)) {
          // 如果所有的status===0 则将childNodeList=[]
          return { ...parentItem, childNodeList: [] }
        } else if (childNodeList.every((child) => child.status === '1')) {
          // 如果status ===1 则将===1的返回
          return parentItem
        } else {
          // 如果有status===0 和 status===1 则过滤掉status===0的
          const filteredChildren = childNodeList.filter((child) => child.status !== '0')
          return { ...parentItem, childNodeList: filteredChildren }
        }
      })
    },
    // 推送商合的时候是否可以进行推送
    isPossibleToPush(dataObj) {
      const { isPush, pushMsg, equipCount, servCount } = dataObj
      let pushState = ''
      let promptMsg = ''
      if (isPush === '0' && pushMsg !== '' && pushMsg !== null) { // 推送服务失败
        pushState = '0'
        promptMsg = '校验未通过，请根据提示进行处理，商合系统提示：' + pushMsg
      } else if (isPush === '2') { // 等待交易处理服务结果
        pushState = '2'
        promptMsg = '请等待商合交易系统处理服务数据返回结果'
      } else if (isPush === '0' && servCount > 0) { // 服务调整
        pushState = '3'
        promptMsg = '请先点击【推送商合】按钮推送服务'
      } else if (isPush === '1' && equipCount > 0) { // 服务推送成功
        pushState = '1'
        promptMsg = '服务推送成功，请点击【推送商合】推送物资'
      } else if (isPush === '0' && equipCount > 0) { // 物资调整
        pushState = '4'
        promptMsg = '请先点击【推送商合】按钮推送物资'
      } else if (servCount === '0' && equipCount === '0' && isPush === '0') { // 数据未调整
        pushState = '5'
        promptMsg = '数据未调整无需推送商合'
      } else if (servCount === '0' && equipCount === '0' && isPush === '1') { // 都已推送商合
        pushState = '6'
        promptMsg = '数据已推送商合成功'
      } else {
        pushState = '7'
        promptMsg = '未知进度，请联系技术人员支撑'
      }
      return { pushState, promptMsg }
    },
    defaultZero(value) {
      // 使用逻辑运算符进行判断和返回
      return value === '' || value === undefined || value === null ? 0 : value
    },
    // 通用提示消息
    messagePrompt(message) {
      Message({
        message: message,
        type: 'warning'
      })
    },
    // 服务明细校验
    serviceVerification(data, tableData, lastCount, column) {
      const ifSinglePro = '0'// 是否单项工程项目1时，0否  从 url获取存在就拿不存在给0
      const [item, , row] = data
      // 针对服务需要判断如何调增调减
      const saveEqual = tableData.map(items_ => {
        if (items_.childNodeList && items_.childNodeList.length > 0) {
          // 只取服务编码 和订单号相同的
          return items_.childNodeList.filter(_item => (_item.orderNo === row.orderNo && _item.categoryCode === row.categoryCode))
        }
      })
      // 将二维数组转为一维数组
      const toChangeList = saveEqual.flat()
      // 合价不含税累积合计
      const sumTotal = toChangeList.reduce((accumulator, currentObject) => (+accumulator) + (+currentObject.equipSum), 0)
      // 变化合价累积合计
      const sumChangePriceTotal = toChangeList.reduce((accumulator, currentObject) => (+accumulator) + (+currentObject.changePrice), 0)
      // 判断当前点击那个单元格
      if (item === 'changeNum') {
        this.serviceUpdateNum(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
      } else if (item === 'changePrice') {
        this.serviceUpdatePrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
      } else if (item === 'adjustedPrice') {
        this.serviceUpdateAdjustedPrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
      } else {
        console.log('car')
      }
    },
    optimizeNewUpserviceUpdateNumOne(sumTotal, row, sumChangePriceTotal) {
      return sumTotal > 0 && (+row['changeNum']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
    },
    optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc) {
      return this.judgeIsTurnkeyServices(row) && spuUnitAcc !== null && spuUnitAcc !== ''
    },
    optimizeNewUpserviceUpdateNumThree(numConfig, precent) {
      return Number(numConfig) !== 0 && precent > Number(numConfig)
    },
    optimizeNewUpserviceUpdateNumFour(doneNum1, ifsb) {
      return this.isFloat(doneNum1) && ifsb !== '0'
    },
    optimizeNewUpserviceUpdateNumFive(doneNum1, special) {
      return doneNum1 < 0 || special
    },
    optimizeNewUpserviceUpdateNumSix(row) {
      return +row['changeNum'] === 0 || row['changeNum'] === '' || +row['changeNum'] == null
    },
    optimizeNewUpserviceUpdateNumSeven(changeNum, row) {
      return !(changeNum === '' || +row['changeNum'] === 0)
    },
    optimizeNewUpserviceUpdateNumEight(changeNum, row) {
      let changeStatus = row['changeStatus']
      if (+changeNum > 0) {
        changeStatus = '0' // 赋值
        } else {
          changeStatus = '1' // 赋值
        }
        return changeStatus
    },
    // 维护改造类2021.11.11 修复阻断
   async optimizeWHserviceUpdateNumOne(row, spuUnitAcc) {
     // 判断总包是否符合条件符合进入逻辑
     if (this.optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc)) {
       //    变化数量
       row['changeNum'] = (+row['changeNum']).toFixed(4)
     }
   },
   async optimizeWHserviceUpdateNumTwo(row) {
    if (+row['changeNum'] === 0) {
        // 变化数量赋值
        row['changeNum'] = ''
      }
   },
   async optimizeWHserviceUpdateNumThree(row, numConfig, precent, lastCount) {
    if (this.optimizeNewUpserviceUpdateNumThree(numConfig, precent)) {
        // 提示消息
        this.messagePrompt(`变化数量”超过原数量的"${numConfig * 100}"%！`)
        row['changeNum'] = this.optimizeNewUpUnusableStorageNine(lastCount) // 增调数量赋值
        row['status'] = 0 // 状态赋值
      }
   },
   async optimizeWHserviceUpdateNumFour(row, doneNum1, ifsb, lastCount) {
    if (this.optimizeNewUpserviceUpdateNumFour(doneNum1, ifsb)) {
        // 提示消息
        this.messagePrompt(`变化后数量”的计算结果不能为小数！`)
        row['changeNum'] = this.optimizeNewUpUnusableStorageNine(lastCount) // 增调数量赋值
        row['status'] = 0 // 状态赋值
      }
   },
   async optimizeWHserviceUpdateNumFive(row, doneNum1, special, lastCount) {
    if (this.optimizeNewUpserviceUpdateNumFive(doneNum1, special)) {
        this.messagePrompt(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
        row['changeNum'] = this.optimizeNewUpUnusableStorageNine(lastCount) // 增调数量赋值
        row['status'] = 0// 状态赋值
      }
   },
   async optimizeWHserviceUpdateNumSix(row) {
     if (this.optimizeNewUpserviceUpdateNumSix(row)) {
       row['status'] = 0 // 状态赋值
       row['doneNum'] = ''// 变化后数量
       row['donePrice'] = '' // 变化后合价
       row['changePrice'] = '' // 变化合价
       row['changeStatus'] = '' // 状态
       row['doneAmt'] = '' // 调整后含税总价
       row['doneTaxAmount'] = '' // 调整后税额
       row['adjustedPrice'] = '' // 单价
     }
   },
    softNumCalc(row) {
      let result = ''
      if (this.isSoftProject || +row['amount'] === 0) {
        result = row['changePrice']
      } else {
        result = (parseFloat(row['donePrice']) - parseFloat(row['equipSum']))
      }
      return result
    },
    softNumCalcTwo(row, doneNum1) {
      let result = ''
      if (this.isSoftProject || +row['amount'] === 0) {
        row['changePrice'] = (parseFloat(row['changeNum']) * parseFloat(row['price']))
        result = (+row['equipSum']) + (+row['price'])
      } else {
        result = parseFloat(doneNum1) * parseFloat(row['price'])
      }
      return result
    },
    // 服务明细校验 -校验数量
   async serviceUpdateNum(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
      const { spuUnitAcc, changeNum, amount, scategoryCode, siteId, orderProductId, sourceType, realAmount, percentage, numConfig, ifsb, equipSum
        , taxRate
      } = row
      // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
      const special = this.optimizeNewUpserviceUpdateNumOne(sumTotal, row, sumChangePriceTotal)
      await this.optimizeWHserviceUpdateNumOne(row, spuUnitAcc)
      // 变化数量判断
      await this.optimizeWHserviceUpdateNumTwo(row)
      // 一会判断的时候需要用到比例
      const precent = Math.abs(row['changeNum']) / row['amount']
      // 初始化定义的变量
      const doneNum1 = (+row['changeNum']) + (+row['amount'])
      // 判断比例是否满足条件
      await this.optimizeWHserviceUpdateNumThree(row, numConfig, precent, lastCount)
      await this.optimizeWHserviceUpdateNumFour(row, doneNum1, ifsb, lastCount)
      await this.optimizeWHserviceUpdateNumFive(row, doneNum1, special, lastCount)
      await this.optimizeWHserviceUpdateNumSix(row)
      if (this.optimizeNewUpserviceUpdateNumSeven(changeNum, row)) {
        row['status'] = 1 // 状态改变
        // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
        row['changeStatus'] = this.optimizeNewUpserviceUpdateNumEight(changeNum, row)
        // 变化后合价
        row['donePrice'] = this.softNumCalcTwo(row,doneNum1)
        // 合价(不含税)是否满足条件
        if (equipSum == null) {
          // 合价(不含税)赋值
          row['equipSum'] = 0
        }
        // 税率是否满足条件
        if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
          // 税率赋值
          row['taxRate'] = 0
        }
        // 变化合价
        row['changePrice'] = this.softNumCalc(row)
        // 调整后税额
        row['doneTaxAmount'] = parseFloat(row['donePrice']) * parseFloat(row['taxRate'])
        //    调整后含税总价
        row['doneAmt'] = parseFloat(row['donePrice']) + parseFloat(row['doneTaxAmount'])
        // 定义的变量donePrice1
        const donePrice1 = Math.round(row['donePrice'] * 100) / 100
        // 定义的变量changePrice1
        const changePrice1 = Math.round(row['changePrice'] * 100) / 100
        // 定义的变量doneTaxAmount1
        const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
        // 定义的变量doneAmt1
        const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
        // 判断总包是否满足条件
        if (this.optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc)) {
          row['changePrice'] = (+row['changePrice']).toFixed(2)
        }
        // 计算出来的变化后合价和不含税合价一致还原默认值
        if (+donePrice1 === (+row['equipSum'])) {
          this.messagePrompt('变化数量的值所填过小，变化合价为0，无法推送商合，请重新填写')
          row['changeNum'] = ''
          row['status'] = 0 // 状态赋值
          row['doneNum'] = ''// 变化后数量
          row['donePrice'] = '' // 变化后合价
          row['changePrice'] = '' // 变化合价
          row['changeStatus'] = '' // 状态
          row['doneAmt'] = '' // 调整后含税总价
          row['doneTaxAmount'] = '' // 调整后税额
          row['adjustedPrice'] = '' // 单价
          return Promise.reject()
        }
        // 单价赋值
        row['adjustedPrice'] = ''
        // 增调数量赋值
        row['changeNum'] = (+row['changeNum'])
        // 变化后数量
        row['doneNum'] = doneNum1
        // 变化合价
        row['changePrice'] = +changePrice1
        // 变化后合价
        row['donePrice'] = +donePrice1
        // 调整后含税总价
        row['doneAmt'] = +doneAmt1
        // 调整后税额
        row['doneTaxAmount'] = +doneTaxAmount1
      }
    },
    optimizeNewUpserviceUpdatePriceOne(sumTotal, row, sumChangePriceTotal) {
      return sumTotal > 0 && (+row['changePrice']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
    },
    optimizeNewUpserviceUpdatePriceTwo(changePrice) {
      return changePrice == null || changePrice === '' || changePrice === '0' || Math.abs(parseFloat(changePrice)) < 0.005
    },
    optimizeNewUpserviceUpdatePriceThree(item, scategoryCode, siteId, orderProductId, sourceType) {
      return item.scategoryCode === scategoryCode && item.siteId === siteId && (item.orderProductId !== orderProductId || item.sourceType !== sourceType)
    },
    optimizeNewUpserviceUpdatePriceFour(donePrice2, proportionPrice, percentage01) {
      return parseFloat(donePrice2) > 0 && proportionPrice > percentage01
    },
    optimizeNewUpserviceUpdatePriceFive(row) {
      return row['donePrice'] === '' || row['donePrice'] == null
    },
    optimizeNewUpserviceUpdatePriceSix(row) {
      return !(row['donePrice'] === '' || row['donePrice'] == null)
    },
    optimizeNewUpserviceUpdatePriceSeven(donePrice1, epcServiceType, ifRoomService, codeBusClassification, master) {
      return donePrice1 === 0 && this.optimizeNewUpserviceUpdatePriceEight(epcServiceType, ifRoomService, codeBusClassification) && master > 0
    },
    optimizeNewUpserviceUpdatePriceEight(epcServiceType, ifRoomService, codeBusClassification) {
      return (epcServiceType === '14' || epcServiceType === '4' || ifRoomService === '1' || codeBusClassification === '14')
    },
    optimizeNewUpserviceUpdatePriceNine(donePrice) {
      return donePrice === '' || donePrice == null
    },
    optimizeNewUpserviceUpdatePriceTen(donePrice) {
      return !(donePrice === '' || donePrice == null)
    },
    optimizeNewUpserviceUpdatePriceEleve(row, changePrice) {
      return +row['changePrice'] === 0 || row['changePrice'] === '' || row['changePrice'] == null || Math.abs(parseFloat(changePrice)) < 0.005
    },
    optimizeNewUpserviceUpdatePriceTweleve(changePrice, row) {
      return !(changePrice === '' || +row['changePrice'] === 0)
    },
    optimizeNewUpserviceUpdatePriceThirteen(row) {
      let changeStatus = row['changeStatus']
      if ((+row['changePrice']) > 0) {
        changeStatus = '2'
        } else {
          changeStatus = '3'
        }
        return changeStatus
    },
    optimizeNewUpserviceUpdatePriceFourteen(changePrice, donePrice1) {
      return changePrice < 0 && donePrice1 === '0'
    },
    // 维护改造类2021.11.11 修复阻断
   async optimizeWHserviceUpdatePriceOne(row, special, lastCount) {
    if (special) {
        this.messagePrompt(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
        row['changePrice'] = this.optimizeNewUpUnusableStorageNine(lastCount) // 变化合价
        row['status'] = 0 // 状态
      }
   },
   async optimizeWHserviceUpdatePriceTwo(row, spuUnitAcc) {
    if (this.optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc)) {
        row['changePrice'] = (+row['changePrice']).toFixed(2) // 变化合价重新赋值
      }
   },
   async optimizeWHserviceUpdatePriceThree(row, changePrice) {
    if (this.optimizeNewUpserviceUpdatePriceTwo(changePrice)) {
        row['changePrice'] = '' // 变化合价赋值
      }
   },
   optimizeWHserviceUpdatePriceFour(donePrice3) {
      return donePrice3 === '' || donePrice3 == null
   },
   async optimizeWHserviceUpdatePriceFive(row, donePrice2, proportionPrice) {
     let backproportionPrice = proportionPrice
     if (parseFloat(donePrice2) > 0) {
       // 满足条件重新赋值
       backproportionPrice = (Math.abs(donePrice2) / row['equipSum']) * 100
     }
     return backproportionPrice
   },
   async optimizeWHserviceUpdatePriceSix(row, donePrice2, proportionPrice, percentage01, changePrice, donePrice) {
    if (this.optimizeNewUpserviceUpdatePriceFour(donePrice2, proportionPrice, percentage01)) {
        // 提示消息
        this.messagePrompt(`该类服务所有订单调整后的金额总和不允许超出该类服务设计方案中金额的" + ${percentage01} + "%！`)
        row['changePrice'] = 0 // 变化合价
        row['status'] = 0 // 状态
        // 变化后合价逻辑判断
        if (this.optimizeNewUpserviceUpdatePriceFive(row)) {
          row['changePrice'] = '' // 变化后合价
        }
         if (this.optimizeNewUpserviceUpdatePriceSix(row)) {
          row['changePrice'] = changePrice // 变化合价
          row['donePrice'] = donePrice // 变化后合价
        }
      }
   },
   async optimizeWHserviceUpdatePriceSeven(row, donePrice1, epcServiceType, ifRoomService, codeBusClassification, master, donePrice, changePrice) {
     if (this.optimizeNewUpserviceUpdatePriceSeven(donePrice1, epcServiceType, ifRoomService, codeBusClassification, master)) { // 总包服务订单在项目结算调整时，如果该站址总包服务的构成明细中含有主设备物资，那么系统管控当前总包服务订单的合价金额不允许调整为0。
       this.messagePrompt('总包服务、砖混/框架机房服务、外电引入施工服务订单的合价金额不允许调整为0！')
       row['changePrice'] = 0 // 变化合价
       row['status'] = 0 // 状态
       if (this.optimizeNewUpserviceUpdatePriceNine(donePrice)) {
         row['changePrice'] = '' // 变化合价
       }
       if (this.optimizeNewUpserviceUpdatePriceTen(donePrice)) {
         row['changePrice'] = changePrice // 变化合价
         row['donePrice'] = donePrice // 变化后合价
       }
     }
   },
   async optimizeWHserviceUpdatePriceEight(row, donePrice1, lastCount, donePrice, changePrice) {
    if (donePrice1 < 0) {
        // 提示消息
        this.messagePrompt('“变化后合价”的计算结果不能为负数！')
        row['changePrice'] = this.optimizeNewUpUnusableStorageNine(lastCount) // 变化合价
        row['status'] = 0 // 状态
        // 判断是否满足条件
        if (this.optimizeNewUpserviceUpdatePriceNine(donePrice)) {
          // 变化合价
          row['changePrice'] = ''
        }
         if (this.optimizeNewUpserviceUpdatePriceTen(donePrice)) {
          row['changePrice'] = changePrice // 变化合价
          row['donePrice'] = donePrice // 变化后合价
        }
      }
   },
   async optimizeWHserviceUpdatePriceNine(row, changePrice) {
    if (this.optimizeNewUpserviceUpdatePriceEleve(row, changePrice)) {
        row['status'] = 0 // 状态
        row['donePrice'] = '' // 变化后合价
        row['changeNum'] = '' // 增调数量
        row['doneNum'] = '' // 变化数量
        row['changeStatus'] = '' // 状态
        row['doneAmt'] = '' // 调整后含税总价
        row['doneTaxAmount'] = '' // 调整后税额
        row['adjustedPrice'] = '' // 单价
      }
   },
   async optimizeWHserviceUpdatePriceTen(row, changePrice, taxRate, donePrice1, spuUnitAcc) {
    if (this.optimizeNewUpserviceUpdatePriceTweleve(changePrice, row)) {
       row['status'] = 1 // 状态
       // 2-调增合价；3-调减合价
       row['changeStatus'] = this.optimizeNewUpserviceUpdatePriceThirteen(row)
       // 20181217如果变化了合价，变化后数量与变化数量都不变取原来amount
       // doneNum = parseFloat(donePrice1)/parseFloat(price);
       // doneNum = doneNum.toFixed(5);
       // changeNum = parseFloat(doneNum)-parseFloat(amount);
       // 税率是否满足条件
       if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
         row['taxRate'] = 0 // 税率赋值
       }
       /* 订单金额调增时填写正数，调整数量默认为0
			   订单金额部分调减时填写负数，调整数量默认为0
		       订单金额全部调减时填写负数，调整数量默认为订单原始数量的负数 */
       if (this.optimizeNewUpserviceUpdatePriceFourteen(changePrice, donePrice1)) {
         row['doneNum'] = 0 // 变化后数量
         // 变化数量
         row['changeNum'] = -row['amount']
       } else {
         // 变化后数量
         row['doneNum'] = row['amount']
         // 变化数量
         row['changeNum'] = 0
       }
       // 调整后税额
       row['doneTaxAmount'] = parseFloat(donePrice1) * parseFloat(row['taxRate'])
       // 调整后含税总价
       row['doneAmt'] = parseFloat(donePrice1) + parseFloat(row['doneTaxAmount'])
       // 初始化定义变量
       const changePrice1 = Math.round(row['changePrice'] * 100) / 100
       // 初始化定义变量
       const donPrice2 = Math.round(donePrice1 * 100) / 100
       // 初始化定义变量
       const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
       // 初始化定义变量
       const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
       // 物料编码五级分类符合下列条件且组合件标识为“是”的工程服务编码属于总包服务
       if (this.optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc)) {
         row['changeNum'] = (+row['changeNum']).toFixed(2) // 增调数量
         row['changePrice'] = (+changePrice).toFixed(2) // 变化合价
       }
       row['adjustedPrice'] = '' // 单价
       row['changePrice'] = changePrice1 // 变化合价
       row['donePrice'] = donPrice2 // 变化后合价
       row['doneNum'] = (+row['doneNum']) // 变化数量
       // 增调数量
       row['changeNum'] = (+row['changeNum']) === 0 ? '' : (+row['changeNum'])
       row['doneAmt'] = doneAmt1 // 调整后含税总价
       row['doneTaxAmount'] = doneTaxAmount1 // 调整后税额
     }
   },
    // 服务明细校验-变化合价
   async serviceUpdatePrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
      const { spuUnitAcc, changePrice, scategoryCode, siteId, orderProductId, sourceType, percentage, equipSum
        , taxRate, donePrice, epcServiceType, ifRoomService, codeBusClassification, master
      } = row
      // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
      const special = this.optimizeNewUpserviceUpdatePriceOne(sumTotal, row, sumChangePriceTotal)
      await this.optimizeWHserviceUpdatePriceOne(row, special, lastCount)
      // 判断总包是否符合条件
      await this.optimizeWHserviceUpdatePriceTwo(row, spuUnitAcc)
      // 初始化定义变量
      const donePrice1 = parseFloat(row['changePrice']) + parseFloat(equipSum)
      // 变化合价判断是否满足条件
      await this.optimizeWHserviceUpdatePriceThree(row, changePrice)
      // 初始化定义变量
      let donePrice2 = parseFloat(row['changePrice']) + parseFloat(row['equipSum'])// 该服务订单调整后金额
      // 筛选过滤出相同类型
      const filterTable = tableData.filter(item => {
        if (this.optimizeNewUpserviceUpdatePriceThree(item, scategoryCode, siteId, orderProductId, sourceType)) {
          return item
        }
      })
      // for循环对当前table进行遍历循环拿到每一项进行复制
      for (let num = 0; num < filterTable.length; num++) {
        // 不含税合价之和
        row['equipSum'] = row['equipSum'] + filterTable[num].equipSum
        // 调整后金额之和
        let donePrice3 = filterTable[num].donePrice // 与该编码相同的服务编码调整后数量
        if (this.optimizeWHserviceUpdatePriceFour(donePrice3)) {
          donePrice3 = filterTable[num].equipSum // 赋值
        }
        // 初始化赋值
        donePrice2 = donePrice2 + parseFloat(donePrice3)
      }
      // 定义初始变量
      let proportionPrice = 0
      // 判断是否满足条件
      proportionPrice = await this.optimizeWHserviceUpdatePriceFive(row, donePrice2, proportionPrice)
      // 定义变量并拿到最新的值
      const percentage01 = percentage + 100
      // 判断是否符合条件
      // await this.optimizeWHserviceUpdatePriceSix(row,donePrice2, proportionPrice, percentage01,changePrice,donePrice)
      await this.optimizeWHserviceUpdatePriceSeven(row, donePrice1, epcServiceType, ifRoomService, codeBusClassification, master, donePrice, changePrice)
      await this.optimizeWHserviceUpdatePriceEight(row, donePrice1, lastCount, donePrice, changePrice)
      await this.optimizeWHserviceUpdatePriceNine(row, changePrice)
      await this.optimizeWHserviceUpdatePriceTen(row, changePrice, taxRate, donePrice1, spuUnitAcc)
    },
    optimizeNewUpserviceUpdateAdjustedPriceOne(sumTotal, row, sumChangePriceTotal) {
      return sumTotal > 0 && (+row['adjustedPrice']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
    },
    optimizeNewUpserviceUpdateAdjustedPriceTwo(adjustedPrice, price) {
      return adjustedPrice == null || adjustedPrice === '' || adjustedPrice === price
    },
    optimizeNewUpserviceUpdateAdjustedPriceThre(changePrice1) {
      return +changePrice1 === 0 ? '' : (+changePrice1)
    },
    optimizeNewUpserviceUpdateAdjustedPriceFour(row) {
      return (+row['changeNum']) === 0 ? '' : (+row['changeNum'])
    },
    // 维护改造类2021.11.11 修复阻断
   async optimizeWHserviceUpdateAdjustedPriceOne(row, special) {
     if (special) {
       this.messagePrompt(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
       // 单价赋值
       row['adjustedPrice'] = ''
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceTwo(row, adjustedPrice, lastCount) {
     if (adjustedPrice === '0') {
       this.messagePrompt('调增后单价不能为0!', lastCount)
       row['adjustedPrice'] = this.optimizeNewUpUnusableStorageNine(lastCount)
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceThree(row, adjustedPrice, price) {
    if (this.optimizeNewUpserviceUpdateAdjustedPriceTwo(adjustedPrice, price)) { // 调整后单价为空或者调整后单价为单价时，默认没有调整
       row['changePrice'] = '' // 变化合价
       row['donePrice'] = '' // 变化后合价
       row['doneNum'] = '' // 变化数量
       row['changeNum'] = '' // 增调数量
       row['status'] = '' // 状态
       row['changeStatus'] = '' // 状态
       row['doneAmt'] = '' // 调整后含税总价
       row['doneTaxAmount'] = '' // 调整后税额
       row['adjustedPrice'] = '' // 单价
       return Promise.reject()
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceFour(row, donePrice1, lastCount, _copyrow, taxRate, changePrice, spuUnitAcc, amount) {
     //    判断是否满足条件
     if (donePrice1 < 0) {
       // 提示消息
       this.messagePrompt(`调整后合价”的计算结果不能为负数`)
       // 单价赋值
       row['adjustedPrice'] = this.optimizeNewUpUnusableStorageNine(lastCount)
     } else {
       // 判断是否满足条件
       await this.optimizeWHserviceUpdateAdjustedPriceSix(row)
       // 变化合价 (调整后单价不含税*数量)-合价不函数
       row['changePrice'] = donePrice1 - row['equipSum']
       // 状态
       row['status'] = 1
       await this.optimizeWHserviceUpdateAdjustedPriceFive(row)
       // 4-调增单价；5-调减单价
       if (+row['changePrice'] === 0) {
         // 当变化合价为0时 还原默认值
         row['changePrice'] = _copyrow.changePrice // 变化合价
         row['donePrice'] = _copyrow.donePrice // 变化后合价
         row['doneNum'] = _copyrow.doneNum // 变化数量
         row['changeNum'] = _copyrow.changeNum // 增调数量
         row['status'] = _copyrow.status // 状态
         row['changeStatus'] = _copyrow.changeStatus // 状态
         row['doneAmt'] = _copyrow.doneAmt// 调整后含税总价
         row['doneTaxAmount'] = _copyrow.doneTaxAmount // 调整后税额
         row['adjustedPrice'] = _copyrow.adjustedPrice// 单价
         return Promise.reject()
       }
       // 税率是否满足条件
       await this.optimizeWHserviceUpdateAdjustedPriceSeven(row, taxRate)
       /* 订单金额调增时填写正数，调整数量默认为0
						         订单金额部分调减时填写负数，调整数量默认为0
						         订单金额全部调减时填写负数，调整数量默认为订单原始数量的负数 */
       if (this.optimizeNewUpserviceUpdatePriceFourteen(+row['changePrice'], donePrice1)) {
         row['doneNum'] = '0' // 变化后数量
         row['changeNum'] = 0 // 变化数量  -amount
       } else {
         row['doneNum'] = amount // 变化后数量
         row['changeNum'] = '0' // 变化数量
       }
       // // 调整后税额
       row['doneTaxAmount'] = parseFloat(donePrice1) * parseFloat(row['taxRate'])
       //  // 调整后含税总价
       row['doneAmt'] = parseFloat(donePrice1) + parseFloat(row['doneTaxAmount'])
       // 初始化定义变量
       const changePrice1 = Math.round((+row['changePrice']) * 100) / 100
       // 初始化定义变量
       const donPrice2 = Math.round(donePrice1 * 100) / 100
       // 初始化定义变量
       const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
       // 初始化定义变量
       const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
       // 物料编码五级分类符合下列条件且组合件标识为“是”的工程服务编码属于总包服务
       if (this.optimizeNewUpserviceUpdateNumTwo(row, spuUnitAcc)) {
         row['changePrice'] = (+row['changePrice']).toFixed(2) // 变化合价
         row['changeNum'] = (+row['changeNum']).toFixed(2) // 变化数量
       }
       // // 变化合价
       row['changePrice'] = this.optimizeNewUpserviceUpdateAdjustedPriceThre(changePrice1)
       // 变化后合价
       row['donePrice'] = donPrice2
       // 变化数量
       row['doneNum'] = (+row['doneNum'])
       // 增调数量
       row['changeNum'] = this.optimizeNewUpserviceUpdateAdjustedPriceFour(row)
       row['doneAmt'] = doneAmt1 // 调整后含税总价
       row['doneTaxAmount'] = doneTaxAmount1 // 调整后税额
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceFive(row) {
     if (+row['changePrice'] > 0) {
       row['changeStatus'] = '4'
     }
     if (+row['changePrice'] < 0) {
       row['changeStatus'] = '5'
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceSix(row) {
     if (Math.abs(parseFloat(row['adjustedPrice'])) < 0.005) {
       // 单价赋值
       row['adjustedPrice'] = 0
     }
   },
   async optimizeWHserviceUpdateAdjustedPriceSeven(row, taxRate) {
     if (this.optimizeNewUpUnusableStorageEight(taxRate)) {
       // 税率赋值
       row['taxRate'] = 0
     }
   },
    // 服务明细校验-调整后单价(不含税)
   async serviceUpdateAdjustedPrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
      // 深拷贝一份 当changePrice =0 还原默认值
      const _copyrow = JSON.parse(JSON.stringify(row))
      const { spuUnitAcc, price, changePrice, amount, scategoryCode, siteId, orderProductId, sourceType, taxRate, adjustedPrice
      } = row
     
      // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
      const special = this.optimizeNewUpserviceUpdateAdjustedPriceOne(sumTotal, row, sumChangePriceTotal)
      await this.optimizeWHserviceUpdateAdjustedPriceOne(row, special)
      // 单价是否满足条件
      await this.optimizeWHserviceUpdateAdjustedPriceTwo(row, adjustedPrice, lastCount)
      await this.optimizeWHserviceUpdateAdjustedPriceThree(row, adjustedPrice, price)
      // 初始化定义变量
      const donePrice1 = parseFloat((+row['adjustedPrice'])) * parseFloat((+row['amount']))// 调整后金额 = 调整后单价 * 数量
      await this.optimizeWHserviceUpdateAdjustedPriceFour(row, donePrice1, lastCount, _copyrow, taxRate, changePrice, spuUnitAcc, amount)
    },
    // 判断是否总包服务并且为组合件
    judgeIsTurnkeyServices(record) {
      const turnkeyServicesCategoryCodes = [
        '9030010109', '9030010207', '9030020107', '9030020204',
        '9030020301', '9030030106', '9030030206', '9030070104',
        '9030070202', '9030010110', '9030020108', '9030020302',
        '9030030107', '9030030207', '9030070105'
      ]
      const { categoryCode, ifMulti } = record
      const isTurnkeyService = turnkeyServicesCategoryCodes.includes(categoryCode.substr(0, 10)) && ifMulti === '0'
      return isTurnkeyService
    },
    isFloat(n) {
      // 判断两个谁大谁小
      return parseInt(n) < parseFloat(n)
    }
  }
}
</script>
<style lang="scss" scoped>
::v-deep .el-tabs__header {
  margin: 0 0 0 0;
}
</style>
